Exemplo n.º 1
0
def test_load_library_initializes_library():
    image_library = MagicMock(spec=ImageLibrary)
    test_subject = ImageRetrievalFactory.LibraryRetrieval((0,0))

    test_subject.load_library(image_library)

    image_library.init.assert_called_with()
Exemplo n.º 2
0
def test_load_library_fails_with_invalid_object():
    test_subject = ImageRetrievalFactory.LibraryRetrieval((0,0))

    try:
        test_subject.load_library('image_library')
        raise RuntimeError("expected ValueError")
    except ValueError:
        pass
Exemplo n.º 3
0
def test_get_fails_when_library_has_not_been_loaded():
    xy = (2, 2)
    test_subject = ImageRetrievalFactory.LibraryRetrieval(xy)

    try:
        test_subject.get((10, 20, 30))
        raise RuntimeError("expected ValueError")
    except ValueError:
        pass
Exemplo n.º 4
0
def test_get_pixel():
    xy = (2, 2)
    testSubject = ImageRetrievalFactory.ReflectiveRetrieval(xy, image_file)

    result = testSubject.get((10, 20, 30))

    assert len(result) == xy[0]
    for x in range(0, len(result)):
        assert len(result[x]) == xy[1]
        for y in range(0, len(result[x])):
            assert isinstance(result[x][y], tuple)
Exemplo n.º 5
0
def test_get_pixel():
    xy = (2, 2)
    image_library = MagicMock(spec=ImageLibrary)
    test_subject = ImageRetrievalFactory.LibraryRetrieval(xy)

    test_subject.load_library(image_library)
    image_library.next.return_value = 'test/data/nature.jpg'

    result = test_subject.get((10, 20, 30))

    assert isinstance(result, list)
    assert isinstance(result[0], list)
def test_get_pixel():
    xy = (2, 2)
    testSubject = ImageRetrievalFactory.DummyRetrieval(xy)

    pixel = (10, 20, 30)
    result = testSubject.get(pixel)

    assert len(result) == xy[0]
    for x in range(0, len(result)):
        assert len(result[x]) == xy[1]
        for y in range(0, len(result[x])):
            assert result[x][y] == pixel
def test_construct_self_search():
    retriever = ImageRetrievalFactory.construct('self', (1, 1),
                                                'test/data/nature.jpg')
    assert retriever != None
def test_construct_dummy_search():
    retriever = ImageRetrievalFactory.construct('none', (1, 1), 'n/a')
    assert retriever != None
def test_construct_unsupported_type():
    try:
        ImageRetrievalFactory.construct('other', (1, 1), 'n/a')
        raise RuntimeError("expected TypeError")
    except ValueError:
        pass
def test_construct_library_search():
    retriever = ImageRetrievalFactory.construct('library', (1, 1), 'n/a')
    assert retriever != None
Exemplo n.º 11
0
                        type=int,
                        help='Mosaic thumbnail tile Y dimension')
arg_parser.add_argument('-o',
                        dest='output_file',
                        type=str,
                        required=True,
                        help='Mosaic output image name')

args = arg_parser.parse_args()

# mosaic creation constructs
dimensions = (args.x or args.thumb_size, args.y or args.thumb_size)
image_mapper = ImageMapper()
mosaic_builder = Mosaic()
pixel_analyzer = PixelAnalyzer()
image_retriever = ImageRetrievalFactory.construct(args.source_type, dimensions,
                                                  args.input_file)
image_library = ImageLibrary()

print("Parsing source image...")
mosaic = mosaic_builder.tile(image_mapper.read_pixels(args.input_file),
                             dimensions)

if args.source_type == ImageRetrievalFactory.RETRIEVE_LIBRARY:
    print("Loading image library...")
    image_retriever.load_library(image_library)

print("Generating photomosaic...")
for i in range(0, len(mosaic)):
    for j in range(0, len(mosaic[i])):
        mosaic[i][j] = image_retriever.get(pixel_analyzer.average(
            mosaic[i][j]))