|
|
| from transformers import pipeline |
| from bs4 import BeautifulSoup |
| import requests |
| import urllib |
| import json |
| import argparse |
| from pathlib import Path |
| import os |
|
|
| from controlnet_aux.processor import Processor |
| from colorthief import ColorThief |
| from colors import name_that_color, rgb_to_hex, NTC_NAMES, CSS3_NAMES |
|
|
| from PIL import Image |
|
|
|
|
| class Scraper(object): |
| def __init__(self, urls): |
| self.urls = urls |
|
|
| def fetch(self, url): |
| return requests.get(url, headers={"User-Agent": "Mozilla/5.0"}) |
|
|
| def parse(self, text): |
| return BeautifulSoup(text, 'html.parser') |
|
|
| def download_image(self, url, path): |
| image = requests.get(url) |
| open(path, 'wb').write(image.content) |
|
|
|
|
| class GraffitiDatabaseScraper(Scraper): |
| def __init__(self): |
| Scraper.__init__(self, ["https://graffiti-database.com"]) |
|
|
| def get_image_urls(self, parsed): |
| pages = parsed.select('.image-info a') |
| image_urls = [] |
| for page in pages: |
| image_urls.append(page.get('href')) |
| return image_urls |
|
|
| def scrape_image(self, url): |
| print("Scraping image page {0}".format(url)) |
|
|
| fetched = self.fetch(url) |
|
|
| if fetched.status_code != 200: |
| raise "Scraping image page did fail" |
|
|
| text = fetched.text |
| parsed = self.parse(text) |
|
|
| image = parsed.select('.img-fluid')[0].get('src') |
|
|
| tag_links = parsed.select('a.tag') |
|
|
| url_parts = urllib.parse.unquote( |
| urllib.parse.unquote(url)).rsplit("/", 2) |
| artist = url_parts[1] |
| return { |
| "image_url": image, |
| "city": tag_links[-1].get_text().strip(), |
| "artist": artist if artist != "Writer Unknown" and artist != "Writers Unknown" else None |
| } |
|
|
| def scrape_page(self, url): |
| print("Scraping page {0}".format(url)) |
|
|
| text = self.fetch(url).text |
| parsed = self.parse(text) |
|
|
| image_urls = self.get_image_urls(parsed) |
|
|
| if len(image_urls) == 0: |
| return False |
|
|
| for image_url in image_urls: |
| try: |
| result = self.scrape_image( |
| "https://graffiti-database.com" + image_url) |
| except: |
| continue |
|
|
| file_name = result["image_url"].split('/')[-1] |
|
|
| self.download_image(result["image_url"], |
| './images/' + file_name) |
|
|
| result["file"] = file_name |
|
|
| with open('./images/' + file_name + '.json', 'w', encoding='utf-8') as f: |
| f.write(json.dumps(result, indent=2, ensure_ascii=False)) |
|
|
| return True |
|
|
| def scrape(self): |
| url = self.urls[0] |
| print("Scraping {0}".format( |
| url)) |
|
|
| count = 1 |
| has_images = True |
| while has_images: |
| has_images = self.scrape_page(url + "?page=" + str(count)) |
| count += 1 |
|
|
|
|
| class GraffitiScraper(Scraper): |
| def __init__(self): |
| Scraper.__init__(self, ["https://www.graffiti.org/index/world.html", |
| "https://www.graffiti.org/index/europe.html", "https://www.graffiti.org/index/usa.html"]) |
|
|
| def scrape_page(self, url, city_name): |
| print("Scraping page {0}".format(url)) |
|
|
| text = self.fetch(url).text |
| parsed = self.parse(text) |
|
|
| image_elements = parsed.select('a[href*=".jpg"]') |
|
|
| for image_element in image_elements: |
| if image_element.get_text().strip() == "": |
| tags = image_element.find_next_sibling(string=True).get_text( |
| ).strip() if image_element.find_next_sibling(string=True) else "" |
| else: |
| continue |
| image_url = image_element.get("href").replace("/", "_") |
| url_parts = url.split('/') |
| url_parts[-1] = image_element.get("href") |
| self.download_image("/".join(url_parts), |
| './images/' + image_url) |
|
|
| with open('./images/' + image_url + '.json', 'w', encoding='utf-8') as f: |
| f.write(json.dumps({ |
| "file": image_url, |
| "image_url": "/".join(url_parts), |
| "artist": tags, |
| "city": city_name if city_name != "Various cities" else None |
| }, indent=2, ensure_ascii=False)) |
|
|
| def scrape_url(self, url): |
| print("Scraping url {0}".format(url)) |
|
|
| text = self.fetch(url).text |
| parsed = self.parse(text) |
|
|
| cities = parsed.find_all("h4") |
|
|
| for city in cities: |
| city_name = city.get_text().split("\n")[0].strip() |
| pages = city.find_all("a") |
| for page in pages: |
| if page.get_text().strip() == "§": |
| continue |
| self.scrape_page( |
| "https://www.graffiti.org/index/" + page.get("href"), city_name) |
|
|
| def scrape(self): |
| for url in self.urls: |
| self.scrape_url(url) |
|
|
|
|
| class CLI(): |
| def __init__(self): |
| parser = argparse.ArgumentParser( |
| prog='graffiti-cli', |
| description='Tools for setting up the dataset') |
| subparsers = parser.add_subparsers(dest="command", required=True) |
|
|
| scrape = subparsers.add_parser( |
| 'scrape', help='Scrapes data sources and downloads images') |
| scrape.add_argument('--source', |
| default='graffiti.org', |
| choices=['graffiti.org', 'graffiti-database.com'], |
| help='Choose data source to scrape') |
| subparsers.add_parser('cleanup', help='Cleans up downloaded images') |
| subparsers.add_parser('caption', help='Captions downloaded images') |
| subparsers.add_parser('palette', help='Creates color palettes for downloaded images') |
| subparsers.add_parser('condition', help='Condition downloaded images') |
| metadata = subparsers.add_parser('metadata', help='Creates single meta files from metadata.jsonl') |
| metadata.add_argument('--source', |
| default='graffiti.org', |
| choices=['graffiti.org', 'graffiti-database.com'], |
| help='Choose data source to use') |
|
|
| args = parser.parse_args() |
| if args.command == 'scrape': |
| if args.source == 'graffiti.org': |
| GraffitiScraper().scrape() |
| elif args.source == 'graffiti-database.com': |
| GraffitiDatabaseScraper().scrape() |
| elif args.command == 'cleanup': |
| path = Path("./images").rglob("*.jpg") |
| for i, img_p in enumerate(path): |
| try: |
| Image.open(img_p).load() |
| except Exception: |
| path_name = str(img_p) |
| print(path_name + " is broken. Deleting!") |
| os.remove(path_name) |
| os.remove(path_name + ".json") |
| elif args.command == 'caption': |
| captioner = pipeline( |
| "image-to-text", model="Salesforce/blip-image-captioning-base") |
| path = Path("./images").rglob("*.jpg") |
| count = len(list(Path("./images").rglob("*.jpg"))) |
| for i, img_p in enumerate(path): |
| path_name = str(img_p) |
| with open(path_name + ".json", 'r+', encoding='utf-8') as f: |
| data = json.load(f) |
|
|
| f.seek(0) |
|
|
| caption = captioner(path_name)[0]["generated_text"] |
|
|
| if "album" in caption: |
| caption = "a wall with graffiti on it" |
|
|
| json.dump({ |
| "file": data["file"], |
| "image_url": data["image_url"], |
| "artist": data["artist"], |
| "city": data["city"], |
| "caption": caption |
| }, f, indent=2) |
| f.truncate() |
|
|
| print("{0} / {1}".format(i + 1, count), path_name, caption) |
| elif args.command == 'palette': |
| path = Path("./images").rglob("*.jpg") |
| count = len(list(Path("./images").rglob("*.jpg"))) |
| for i, img_p in enumerate(path): |
| path_name = str(img_p) |
| with open(path_name + ".json", 'r+', encoding='utf-8') as f: |
| data = json.load(f) |
|
|
| f.seek(0) |
|
|
| color_thief = ColorThief(path_name) |
|
|
| palette = [] |
| for color in color_thief.get_palette(color_count=6): |
| color_hex = rgb_to_hex(color) |
| palette.append([color_hex, name_that_color(color_hex, NTC_NAMES), name_that_color(color_hex, CSS3_NAMES)]) |
|
|
|
|
| json.dump({ |
| "file": data["file"], |
| "image_url": data["image_url"], |
| "artist": data["artist"], |
| "city": data["city"], |
| "caption": data["caption"], |
| "palette": palette |
| }, f, indent=2) |
| f.truncate() |
|
|
| print("{0} / {1}".format(i + 1, count), path_name, palette) |
| elif args.command == 'metadata': |
| with open("data/" + args.source + "/metadata.jsonl", encoding="utf-8") as f: |
| for row in f: |
| data = json.loads(row) |
| with open('./images/' + data["file"] + '.json', 'w') as j: |
| j.write(json.dumps(data, indent=2, ensure_ascii=False)) |
| elif args.command == 'conditioning': |
| processor_id = 'softedge_hed' |
| processor = Processor(processor_id) |
|
|
| path = Path("./images").rglob("*.jpg") |
| count = len(list(Path("./images").rglob("*.jpg"))) |
| for i, img_p in enumerate(path): |
| path_name = str(img_p) |
| output_path = path_name.replace("images/", "conditioning/") |
| img = Image.open(img_p).convert("RGB") |
|
|
| processed_image = processor(img, to_pil=True) |
| processed_image.save(output_path) |
|
|
| print("{0} / {1}".format(i + 1, count), path_name, output_path) |
|
|
| def main(): |
| CLI() |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
