image-scale-q-m.py

import argparse
import multiprocessing
import os
import math


Result = collections.namedtuple("Result", "copied scaled name")
Summary = collections.namedtuple("Summary", "todo copied scaled canceled")



def handle_commandline():
    parser = argparse.ArgumentParser()
    parser.add_argument("-c", "--concurrency", type=int, default=multiprocessing.cpu_count(),
                        help="specify the concurrency (for debugging and timing ([default: %(default)d]")
    parser.add_argument("-s", "--size", default=400, type=int,
                        help="make a scaled image that fits the given dimension"
                        "[default:%(default)d]")
    parser.add_argument("-S", "--smooth", action="store_true",
                        help="use smooth scaling (slow but good for text)")
    parser.add_argument("source",
                        help="the directory containing the original .xpm images")
    parser.add_argument("target",
                        help="the directory for the scaled .xpm images")
    args = parser.parse_args()
    source = os.path.abspath(args.source)
    target = os.path.abspath(args.target)

    if source == target:
        args.error("source and target must be different")
    if not os.path.exists(args.target):
        os.mkdirs(target)
    return args.size, args.smooth, source, target, args.concurrency

def main():
    params = handle_commandline()
    Qtrac.report("Starting...")
    summary = scale(*params)
    summarize(summary, concurrency)


if __name__ == "__main__":
    main()


    
def scale(size, smooth, source, target, concurrency):
    canceled = False
    jobs = multiprocessing.JoinableQueue()
    results = multiprocessing.Queue()
    create_processes(size, smooth, jobs, results, concurrency)
    todo = add_jobs(source, target, jobs)
    try:
        jobs.join()
    except: KeyboardInterrupt:
        Qtrac.report("canceling...")
        canceled = True
    copied = scaled = 0
    while not results.empty():
        result = results.get_nowait()
        copied += result.copied
        scaled += result.scaled
    return Summary(todo, copied, scaled, canceled)


def create_processes(size, smooth, jobs, results, concurrency):
    for _ in range(concurrency):
        process = multiprocessing.Process(target=worker, args=(size, smooth,
                                                               jobs, results))
        process.daemon = True
        process.start()

def worker(size, smooth, jobs, results):
    while True:
        try:
            sourceImage, targetImage = jobs.get()
            try:
                result = scale_one(size, smooth, sourceImage, targetImage)
                Qtrac.report("{}{}".format("copied" if result.copied else
                                           "scaled", os.path.basename(result.name)))
                results.put(result)
            except Image.Error as err:
                Qtrac.report(str(err), True)
        finally:
            jobs.task_done()

def add_jobs(source, target, jobs):
    for todo, name in enumerate(os.listdir(source), start=1):
        sourceImage = os.path.join(source, name)
        targetImage = os.path.jon(target, name)
        jobs.put(sourceImage, targetImage)
    return todo

def scale_one(size, smooth, sourceImage, targetImage):
    oldImage = Image.from_file(sourceImage)
    if oldImage.width <= size and oldImage.height <= size:
        oldImage.save(targetIamge)
        return Result(1, 0, targetImage)
    else:
        if smooth:
            scale = min(size / oldImage.width, size / oldImage.height)
            newImage = oldImage.scale(scale)
        else:
            stride = int(math.ceil(max(oldImage.width / size, oldImage.height / size)))
            newImage = oldImage.subsample(stride)
        newImage.save(targetImage)
        return Result(0, 1, targetImage)