示例#1
0
/**
 * Tests the collage code with the appropriate algorithm.
 */
void testCollage(DrawAlgorithm algorithm)
{
    cout << "Testing collage:" << endl;
    vector<PNG> layers = setupImages();
    vector<Point> coords = setupPoints();
    Collage collage(layers, coords);

    double startTime = omp_get_wtime();
    PNG* result = collage.draw(algorithm, true);
    double endTime = omp_get_wtime();
    double parallelTime = endTime - startTime;

    cout << "  - saving image" << endl;
    result->writeToFile("collage.png");    
    cout << "Elapsed collage time: " << parallelTime << endl;

    cout << "Checking correctness: ";
    bool correct = collage.checkCorrectness(*result);
    cout << (correct ? makeGreen("PASS") : makeRed("FAIL") + " (the images are different)") << endl;
    delete result;

    startTime = omp_get_wtime();
    result = collage.draw(algorithm, false);
    endTime = omp_get_wtime();
    cout << "Speedup: " << (endTime - startTime) / parallelTime << endl;
    delete result;
}
示例#2
0
void testWaterfall()
{
	cout << "[main]: " << __func__ << "()" << endl;
	PNG in("in_05.png");

	List<RGBAPixel> list = imageToList(in);
	list.waterfall();

	PNG out = listToImage(list, in.width(), in.height());
	out.writeToFile("waterfall_01.png");

	checkSoln(__func__, out, "soln_waterfall_01.png");

	in.readFromFile("in_06.png");
	list = imageToList(in);
	list.waterfall();
	out = listToImage(list, in.width(), in.height());
	out.writeToFile("waterfall_02.png");

	checkSoln(__func__, out, "soln_waterfall_02.png");
	
	List<int> list3;

	for (int i = 1; i <= 8; i++)
	list3.insertBack(i);
	list3.waterfall();
	//cout << "[waterfall custom]: " << list3 << endl;
}
示例#3
0
bool rx_save_png(Image& img, std::string filename, bool datapath) {
  
  PNG png;

  png_uint_32 type;

  if(img.getPixelFormat() == RX_FMT_GRAY8) {
    type = PNG_COLOR_TYPE_GRAY;
  }
  else if(img.getPixelFormat() == RX_FMT_RGB24) {
    type = PNG_COLOR_TYPE_RGB;
  }
  else if(img.getPixelFormat() == RX_FMT_RGBA32) {
    type = PNG_COLOR_TYPE_RGB_ALPHA;
  }
  else {
    RX_ERROR(ERR_IMG_UNSUPPORTED_FORMAT);
    return false;
  }

  png.setPixels(img.getPixels(), img.getWidth(), img.getHeight(), type);
  png.save(filename, datapath);

  return true;
}
示例#4
0
/**
 * Tests the image flipping code.
 */
void testFlip()
{
    PNG image;
    cout << "Testing in-place image flipper:" << endl;
    image.readFromFile("images/03_2560x1680.png");

    cout << "  - flipping image" << endl;
    double startTime = omp_get_wtime();
    Flipper::flipParallel(image);
    double endTime = omp_get_wtime();
    double parallelTime = endTime - startTime;

    cout << "  - saving image" << endl;
    image.writeToFile("flipped.png");
    cout << "Elapsed flip time: " << parallelTime << endl;

    cout << "Checking correctness: ";
    bool correct = Flipper::checkCorrectness(image);
    cout << (correct ? makeGreen("PASS") : makeRed("FAIL") + " (the images are different)") << endl;

    startTime = omp_get_wtime();
    Flipper::flipSerial(image);
    endTime = omp_get_wtime();
    cout << "Speedup: " << (endTime - startTime) / parallelTime << endl;
}
int main()
{ 
   SquareMaze m;
   m.makeMaze(TEST,TEST);
   std::cout << "MakeMaze complete" << std::endl;

    /*
    for ( int i = 0; i < TEST; i++)
    {
        for ( int j = 0; j < TEST ; j++)
        {
            cout <<"RIGHT: "<< m.canTravel(i,j,RIGHT)<< " x: "<<i<<" y: "<<j<<endl;
            cout <<"BOTTOM: "<< m.canTravel(i,j,BOTTOM)<< " x: "<<i<<" y: "<<j<<endl;
        }
    }
    */

   PNG* unsolved = m.drawMaze();
   unsolved->writeToFile("unsolved.png");
   delete unsolved;
   std::cout << "drawMaze complete" << std::endl;
   
   vector<int> sol = m.solveMaze();
   std::cout << "solveMaze complete" << std::endl;
   
   PNG* solved = m.drawMazeWithSolution();
   solved->writeToFile("solved.png");
   delete solved;
   std::cout << "drawMazeWithSolution complete" << std::endl;

   return 0;
}
示例#6
0
/**
 * Tests the image shifting code
 */
void testShift()
{
    // remove old frames
    system("rm -rf frames 2> /dev/null");

    PNG image;
    cout << "Testing image shifter:" << endl;
    image.readFromFile("images/08_1024x768.png");

    cout << "  - shifting image" << endl;
    double startTime = omp_get_wtime();
    animation anim = Shifter::shiftParallel(image);
    double endTime = omp_get_wtime();
    double parallelTime = endTime - startTime;

    cout << "  - saving image" << endl;
    anim.write("shifted.gif");
    cout << "Elapsed shifting time: " << parallelTime << endl;

    cout << "Checking correctness: ";
    bool correct = Shifter::checkCorrectness();
    cout << (correct ? makeGreen("PASS") : makeRed("FAIL") + " (the images are different)") << endl;

    // remove old frames
    system("rm -rf frames 2> /dev/null");

    // calculate speedup
    startTime = omp_get_wtime();
    anim = Shifter::shiftSerial(image);
    endTime = omp_get_wtime();

    cout << "Speedup: " << (endTime - startTime) / parallelTime << endl;
}
示例#7
0
void Terrain::loadHeightMap(string filename, int res_x, int res_y)
{
	PNG inputFile;
	inputFile.load(filename);
	dim_x = inputFile.width;
	dim_y = inputFile.height;
	unsigned char * data = inputFile.getData();

	int size = dim_x*dim_y;
	float * originalHeightMap = new float[size];
	int i,x,y;

	for (i=0; i<size; i++){
		originalHeightMap[i] = 256*data[2*i]+data[2*i + 1];
	}
	// recalculate to the given resolution (use linear interpolation...)
	size = res_x*res_y;
	heightMap = new float[size];
	float step_x = float(dim_x)/float(res_x);
	float step_y = float(dim_y)/float(res_y);
	
	for(x=0; x<res_x; x++)
	{
		for(y=0; y<res_y; y++)
		{
			heightMap[x*res_y + y] = getHeightAt(originalHeightMap, dim_x, dim_y, float(x*step_x), float(y*step_y));
		}
	}
	SAFE_DELETE_ARRAY_PTR(originalHeightMap);

}
示例#8
0
void testReverseNth()
{
	cout << "[main]: " << __func__ << "()" << endl;
	PNG in("in_03.png");
	
    /*
    List<int> test;

    for (int i = 1; i <= 11; i++)
    {
        test.insertBack(i);
    }

    cout<<test<<endl;
    test.reverseNth(3);
    cout<<test<<endl;
    */
	List<RGBAPixel> list = imageToList(in);
	list.reverseNth(in.height() * 20);

	PNG out = listToImage(list, in.width(), in.height());
	out.writeToFile("reverseNth_01.png");

	checkSoln(__func__, out, "soln_reverseNth_01.png");

	in.readFromFile("in_04.png");
	list = imageToList(in);
	list.reverseNth(in.height() * 61);
	out = listToImage(list, in.width(), in.height());
	out.writeToFile("reverseNth_02.png");

	checkSoln(__func__, out, "soln_reverseNth_02.png");

}
示例#9
0
void testWaterfall()
{
	List<double> li;
	cout<<li<<endl;
	li.waterfall();
	cout<<li<<endl;
	cout << "[main]: " << __func__ << "()" << endl;
	PNG in("in_05.png");

	List<RGBAPixel> list = imageToList(in);
	list.waterfall();

	PNG out = listToImage(list, in.width(), in.height());
	out.writeToFile("waterfall_01.png");

	checkSoln(__func__, out, "soln_waterfall_01.png");

	in.readFromFile("in_06.png");
	list = imageToList(in);
	list.waterfall();
	out = listToImage(list, in.width(), in.height());
	out.writeToFile("waterfall_02.png");

	checkSoln(__func__, out, "soln_waterfall_02.png");
}
示例#10
0
int main(int argc, char* argv[])
{
	const int canvas_width = 128;
	const int canvas_height = 128;

	PNG canvas;
	canvas.resize(canvas_width, canvas_height);


	const RGBAPixel triangle_color = color::ORANGE;
	Shape* triangle = new Triangle(triangle_color,
			Vector2(32, 32),
			Vector2(64, 64),
			Vector2(32, 64));

	triangle->draw(&canvas);

	canvas.writeToFile("test_destructor.png");

	/* TODO: Why is this leaking memory?  Triangle does have a valid destructor!?
	 * Can you stop it from leaking WITHOUT changing triangle's type from a
	 * Shape pointer to a Triangle pointer type? */
	delete triangle;
	triangle = NULL;

	return 0;
}
示例#11
0
/**
 * This function brightens a rectangle of a PNG, increasing the components
 * (red, green, blue) of each pixel by the given amount. You must account
 * for potential overflow issues (color components can only store numbers
 * between 0 and 255). If you attempt to store a value greater than 255
 * into a color component, the result will wrap around (and you won't be
 * able to check if it was greater than 255).
 *
 * @param original A PNG object which holds the image data to be modified.
 * @param amount The integer amount by which to increase each pixel's
 * components.
 *
 * @return The brightened image.
 */
PNG brighten(PNG original, int amount)
{
    /// You can assume amount is positive.
    for (size_t yi = 0; yi < original.height(); yi++)
    {
        for (size_t xi = 0; xi < original.width(); xi++)
        {
            /// Your code here!
		int blue = original(xi, yi)->blue;
		int green = original(xi, yi)->green;
		int red = original(xi, yi)->red;
		if(red+amount<255)
		original(xi,yi)->red= red+amount;
		else
		original(xi,yi)->red= 255;		
        
		if(blue+amount<255)
		original(xi,yi)->blue= blue+amount;
		else
		original(xi,yi)->blue= 255;

		if(green+amount<255)
		original(xi,yi)->green= green+amount;
		else
		original(xi,yi)->green= 255;
	}
    }
    return original;
}
示例#12
0
/**
 * Removes an RGB color component from the PNG.
 * THIS FUNCTION IS GRADED.
 * @todo - parallelize removeColor()
 * @param source - the original PNG
 * @param color - the color to remove
 * @return - a PNG object with an RGB component taken out
 *  of each pixel (if color parameter is valid)
 */
PNG ImageTools::removeColor(const PNG & source, const Color & color)
{
    int width = source.width();
    int height = source.height();
    PNG output(width, height);
	#pragma omp parallel for
    for(int i = 0; i < width; ++i)
    {	
	
        for(int j = 0; j < height; ++j)
        {
            *output(i, j) = *source(i, j);
            switch(color)
            {
                case RED:
                    output(i,j)->red=0;
                    break;
                case GREEN:
                    output(i,j)->green=0;
                    	break;
                case BLUE:
                    output(i,j)->blue=0;
                    	break;
            }
        }
    }

    return output;
}
示例#13
0
/**
 * Makes an animation of an image shifting to the left
 * @param toShift - the image to be shifted
 * @return - an animation of the image being shifted
 */
animation Shifter::shiftParallel(const PNG & toShift)
{
    
 PNG image = toShift;
    animation anim;
    int width = image.width();
    int height = image.height();
    int shiftAmount = 32;

	  // shift image to the left by 32 pixels each iteration
  
	
  for(int destCol = 0; destCol < width; destCol += 32)
    {
        for(int x = 0; x < width - 32; ++x)
        {
	#pragma omp parallel for 
            for(int y = 0; y < height; ++y)
            {
                *image(x, y) = *image(x + 32, y);
            }
        }
        if(destCol % shiftAmount == 0)
        {
            anim.addFrame(image);
        }
    }
    

    return anim;
}
示例#14
0
void makePhotoMosaic(const string & inFile, const string & tileDir, int numTiles, int pixelsPerTile, const string & outFile)
{
	PNG inImage(inFile);
	SourceImage source(inImage, numTiles);
	vector<TileImage> tiles = getTiles(tileDir);

	if (tiles.empty())
	{
		cerr << "ERROR: No tile images found in " << tileDir << endl;
		exit(2);
	}

	MosaicCanvas::enableOutput = true;
	MosaicCanvas * mosaic = mapTiles(source, tiles);
	cerr << endl;

	if (mosaic == NULL)
	{
		cerr << "ERROR: Mosaic generation failed" << endl;
		exit(3);
	}

	PNG result = mosaic->drawMosaic(pixelsPerTile);
	cerr << "Saving Output Image... ";
	result.writeToFile(outFile);
	cerr << "Done" << endl;
	delete mosaic;
}
示例#15
0
文件: main.cpp 项目: Yankkk/C-
/**
 * This function brightens a rectangle of a PNG, increasing the components
 * (red, green, blue) of each pixel by the given amount. You must account
 * for potential overflow issues (color components can only store numbers
 * between 0 and 255). If you attempt to store a value greater than 255
 * into a color component, the result will wrap around (and you won't be
 * able to check if it was greater than 255).
 *
 * @param original A PNG object which holds the image data to be modified.
 * @param amount The integer amount by which to increase each pixel's
 * components.
 *
 * @return The brightened image.
 */
PNG brighten(PNG original, int amount)
{
    /// You can assume amount is positive.
    for (size_t yi = 0; yi < original.height(); yi++)
    {
        for (size_t xi = 0; xi < original.width(); xi++)
        {
		size_t r = original(xi, yi) -> red;
		size_t g = original(xi, yi) -> green;
		size_t b = original(xi, yi) -> blue;		
		r = r + amount;
		g = g + amount;
		b = b + amount;
		if(r > 255){
			r = 255;
		}
		

		if(g > 255){
			g = 255;
		}
	
		if(b > 255){
			b = 255;
		}           

		original(xi, yi) ->red = r;
		original(xi, yi) ->green = g;
		original(xi, yi) ->blue = b;

		/// Your code here!
        }
    }
    return original;
}
示例#16
0
void checkSoln(string test, PNG out, string soln_file)
{
	PNG soln;
	soln.readFromFile(soln_file.c_str());

	if (!(soln == out))
		cerr << "[" << test << "]: Image does not match " << soln_file << endl;
}
int main(int argc, char* argv[])
{
	const int canvas_width = 128;
	const int canvas_height = 128;

	PNG canvas;
	canvas.resize(canvas_width, canvas_height);

	Vector2 rectangle_center(canvas_width / 2, canvas_height / 2);
	const int rectangle_width = canvas_width / 4;
	const int rectangle_height = canvas_height / 4;
	Rectangle* rectangle = new Rectangle(rectangle_center,
			color::BLUE,
			rectangle_width,
			rectangle_height);

	rectangle->draw(&canvas);

	const int rectangle_perimeter = rectangle->perimeter();
	cout << "Rectangle's Perimeter = " << rectangle_perimeter << endl;
	const int rectangle_area = rectangle->area();
	cout << "Rectangle's Area = " << rectangle_area << endl;

	/* But we can treat a Rectangle just like a Shape using a Shape pointer */
	Shape* shape = rectangle;
	const int shape_perimeter = shape->perimeter();
	cout << "Shape's Perimeter = " << shape_perimeter << endl;
	const int shape_area = shape->area();
	cout << "Shape' Area = " << shape_area << endl;

	/* TODO: For some reason the shape's area and perimeter is different from
	 * triangle's area and perimeter even though they are pointing to the same
	 * object!  Can you this this so they are the same WITHOUT changing the
	 * shape's type from a Shape pointer to a Triangle pointer? */
	if (rectangle_perimeter == shape_perimeter)
	{
		cout << "The Perimeters are the same!" << endl;
	} else
	{
		
		cout << "The Perimeters are NOT the same." << endl;
	}

	if (rectangle_area == shape_area)
	{
		cout << "The Areas are the same!" << endl;
	} else
	{
		cout << "The Areas are NOT the same." << endl;
	}

	canvas.writeToFile("test_virtual.png");

	delete rectangle;

	return 0;
}
示例#18
0
bool CTdata::loadFromFiles(const char * filename, int cnt, int scaleX, int scaleY, int scaleZ){
	int divide = 2;
	int chars = 0;
	scX = scaleX;
	scY = scaleY;
	scZ = scaleZ/divide;
	char filen [50];
	unsigned char * rawData;
	PNG ctfile;
	int width=0, height=0, width2, height2; 
	int x,y,z;
	float val;
	for(z=0; z<cnt; z++){
		sprintf(filen, filename, z+1);
		ctfile.clear();
		if (!ctfile.load(filen)){
			return false;
		}
		
		rawData		= ctfile.getData();
		height		= ctfile.height;
		width		= ctfile.width;
		width2		= width/float(divide);
		height2		= height/float(divide);
		if (data==NULL){
			data = new float[cnt*width2*height2]; //data = new float[cnt*width*height];
		}
		for (y=0; y<height2; y++){ //height
			for (x=0; x<width2; x++){ //width
				// 2x 8-bit to 1x 16-bit
				val = 256*rawData[(2*y*width + 2*x)*divide]+rawData[(2*y*width + 2*x)*divide + 1]; //val = 256*rawData[2*y*width + 2*x]+rawData[2*y*width + 2*x + 1];
				// save in array
				data[z*height2*width2 + y*width2 +(width2-1-x)] = val; //data[z*width*height + y*width +x] = val;
			}
		}
		BACKSPACE(chars);
		chars = printf("LOADING CT images: %03i %%",((z+1)*100)/cnt);
	
	}

	dimX = width2;
    dimY = height2;
	dimZ = cnt;
	

	szX = dimX * scX;
	szY = dimY * scY;
	szZ = dimZ * scZ;
	center.x = szX/2.0;
	center.y = szY/2.0;
	center.z = szZ/2.0;

	// backspace...
	BACKSPACE(chars);
	printf("LOADING CT images (%i) DONE\n", cnt);
	return true;
}
示例#19
0
int main()
{
	PNG oldImage;
	oldImage.readFromFile("in.png");	
	size_t vertical = oldImage.height();
	size_t horizontal = oldImage.width();
/*
* have initialized newImage just so that the pixels are accessable 
*/
	PNG newImage;
	newImage.readFromFile("in.png");
/*
 * we will flip the image horizontally and vertically to rotate it by 180 degrees
*/
	for (size_t x = 0; x < oldImage.width(); x++)
	{	
		for (size_t y = 0; y < oldImage.height(); y++)
		{
			newImage(horizontal-x-1, vertical-y-1)->red = oldImage(x,y)->red;
			newImage(horizontal-x-1, vertical-y-1)->green = oldImage(x,y)->green;
			newImage(horizontal-x-1, vertical-y-1)->blue = oldImage(x,y)->blue;
		}
	}
	newImage.writeToFile("out.png");
}	
示例#20
0
GLuint OpenGLInterface::LoadTextureFromPNG( const char* fileName, unsigned int tex )
{
	PNG pngFile;

	if( pngFile.Load( fileName ) )
	{
		tex = CreateTextureFromImageData( pngFile.GetData(), pngFile.GetWidth(), pngFile.GetHeight(), pngFile.GetHasAlpha(), tex );
	}
		
	return tex;
}
示例#21
0
void testReverse()
{
	cout << "[main]: " << __func__ << "()" << endl;
	PNG in("in_02.png");

	List<RGBAPixel> list = imageToList(in);
	list.reverse();
	PNG out = listToImage(list, in.width(), in.height());
	out.writeToFile("reverse.png");

	checkSoln(__func__, out, "soln_reverse.png");
}
示例#22
0
List<RGBAPixel> imageToList(PNG const & img)
{
	List<RGBAPixel> list;
	for (int i = 0; i < img.width(); i++)
	{
		for (int j = 0; j < img.height(); j++)
		{
            list.insertFront(*img(i,j));
		}
	}
	return list;
}
示例#23
0
/**
 * This function accepts a PNG object, two integer coordinates and a color, and
 * proceeds to draw a horizontal line across the image at the y coordinate and
 * a vertical line down the image at the x coordinage using the given color.
 * The modified PNG is then returned.
 *
 * @param original A PNG object which holds the image data to be modified.
 * @param centerX The center x coordinate of the crosshair which is to be drawn.
 * @param centerY The center y coordinate of the crosshair which is to be drawn.
 * @param color The color of the lines to be drawn.
 *
 * @return The image on which a crosshair has been drawn.
 */
PNG drawCrosshairs(PNG original, int centerX, int centerY, RGBAPixel color)
{
    /// This function is already written for you so you can see how to
    /// interact with our PNG class.
    for (size_t x = 0; x < original.width(); x++)
        *original(x, centerY) = color;

    for (size_t y = 0; y < original.height(); y++)
        *original(centerX, y) = color;

    return original;
}
示例#24
0
void testSolidFill( const Filler & filler, const string & outputFile ) {
	PNG img;
	img.readFromFile( SOLIDTESTIMAGE );
	RGBAPixel px( 70, 50, 13 );

    animation anim;
    if( filler == DFS )
        anim = filler::dfs::fillSolid( img, SOLIDX, SOLIDY, px, SOLIDTOLERANCE, SOLIDFRAMEFREQ );
    else
        anim = filler::bfs::fillSolid( img, SOLIDX, SOLIDY, px, SOLIDTOLERANCE, SOLIDFRAMEFREQ );
	anim.write( outputFile );
	cout << "\tWrote " << outputFile << endl;
}
示例#25
0
void testGridFill( const Filler & filler, const string & outputFile ) {
	PNG img;
	img.readFromFile( GRIDTESTIMAGE );
	RGBAPixel px( 70, 25, 70 );

    animation anim;
    if( filler == DFS )
        anim = filler::dfs::fillGrid( img, GRIDX, GRIDY, px, GRIDGRIDSPACING, GRIDTOLERANCE, GRIDFRAMEFREQ );
    else
        anim = filler::bfs::fillGrid( img, GRIDX, GRIDY, px, GRIDGRIDSPACING, GRIDTOLERANCE, GRIDFRAMEFREQ );
	anim.write( outputFile );
	cout << "\tWrote " << outputFile << endl;
}
示例#26
0
/**
 * This function blends, or averages, two PNGs together. That is, each pixel in
 * the returned image consists of the averaged components (red, green, blue) of
 * the two input images.
 *
 * @param firstImage  The first of the two PNGs to be averaged together.
 * @param secondImage The second of the two PNGs to be averaged together.
 *
 * @return The averaged image.
 */
PNG blendImages(PNG firstImage, PNG secondImage)
{
 for (size_t yi = 0; yi < firstImage.height(); yi++)
    {
        for (size_t xi = 0; xi < firstImage.width(); xi++)
        {
    	firstImage(xi, yi)->green =(firstImage(xi, yi)->green+secondImage(xi, yi)->green)/2;
	firstImage(xi, yi)->red =(firstImage(xi, yi)->red+secondImage(xi, yi)->red)/2;
	firstImage(xi, yi)->blue =(firstImage(xi, yi)->blue+secondImage(xi, yi)->blue)/2;
	}
}
    return firstImage;
}
示例#27
0
/**
 * Simply parses the command line args and runs the appropriate functions.
 */
int main(int argc, char* argv[]){

    if(argc != 5)
    {
        cerr << endl;
        cerr << "Please run as " << argv[0] << " numThreads operation imageName saveFile" << endl;
        cerr << "    numThreads    number of threads to use (if #pragma omp... is encountered)" << endl;
        cerr << "    operation     \"flip\" or \"remove\"" << endl;
        cerr << "    imageName     for example, \"images/01_8182x4096.png\"" << endl;
        cerr << "    saveFile      \"yes\" (if you want to save output), \"no\" otherwise" << endl;
        cerr << endl;
        return 1;
    }

    // set the number of thread for the program to use (the first argument)
    omp_set_num_threads(atoi(argv[1]));
    
    // read the parameter PNG from file
    string filename(argv[3]);
    PNG img(filename);
    PNG output;

    cout << "Performing operation..." << endl;
    double start = omp_get_wtime();
    double end;
    if(argv[2][0] == 'f')
    {
        output = ImageTools::verticalFlip(img);
        end = omp_get_wtime();
        if(argv[4][0] == 'y')
        {
            cout << "Saving image..." << endl;
            output.writeToFile("flipped.png");
        }
    }
    else
    {
        Color color = GREEN;
        output = ImageTools::removeColor(img, color);
        end = omp_get_wtime();
        if(argv[4][0] == 'y')
        {
            cout << "Saving image..." << endl;
            output.writeToFile("removed.png");
        }
    }

    cout << "Total processed pixels: " << img.height() * img.width() << endl;
    cout << "Time: " << end - start << " seconds" << endl;
    return 0;
}
示例#28
0
int main()
{
	// Load in.png
	PNG * original = new PNG;

	original -> readFromFile("in.png");
	int width  = original->width();
	int height = original->height();

	cout << "width=" << width << " height=" << height << endl;

	// Create out.png
	PNG * output;
	output = setupOutput(width, height);	

	// Loud our favorite color to color the outline
	RGBAPixel * myPixel = myFavoriteColor(192);
	// Go over the whole image, and if a pixel differs from that to its upper
	// left, color it my favorite color in the output
	for (int y = 1; y < height; y++)
	{
		for (int x = 1; x < width; x++)
		{
			// Calculate the pixel difference
			RGBAPixel * prev = (*original)(x - 1, y - 1);
			RGBAPixel * curr = (*original)(x, y);
			int diff = abs(curr->red   - prev->red  ) +
					   abs(curr->green - prev->green) +
					   abs(curr->blue  - prev->blue );

			// If the pixel is an edge pixel,
			// color the output pixel with my favorite color
			RGBAPixel * currOutPixel = (*output)(x,y);
			if (diff > 100) {
				currOutPixel->blue = myPixel->blue;
				currOutPixel->red = myPixel->red;
				currOutPixel->green = myPixel->green;
			}
		}
	}
	
	// Save the output file
	output->writeToFile("out.png");

	// Clean up memory
	delete myPixel;
	delete output;
	delete original;
	return 0;
}
示例#29
0
/**
 * This function brightens a rectangle of a PNG, increasing the components
 * (red, green, blue) of each pixel by the given amount. You must account
 * for potential overflow issues (color components can only store numbers
 * between 0 and 255). If you attempt to store a value greater than 255
 * into a color component, the result will wrap around (and you won't be
 * able to check if it was greater than 255).
 *
 * @param original A PNG object which holds the image data to be modified.
 * @param amount The integer amount by which to increase each pixel's
 * components.
 *
 * @return The brightened image.
 */
PNG brighten(PNG original, int amount)
{
    /// You can assume amount is positive.
    for (size_t yi = 0; yi < original.height(); yi++)
    {
        for (size_t xi = 0; xi < original.width(); xi++)
        {
            /// Your code here!
            //original(xi,yi)->red = 0;
	    //original(xi,yi)->blue = 0;
	}
    }
    return original;
}
示例#30
0
bool rx_load_png(Image& img, std::string filename, bool datapath) {
  
  PNG png;

  if(!png.load(filename, datapath)) {
    return false;
  }
  
  switch(png.getColorType()) {
    case PNG_COLOR_TYPE_GRAY: {
      img.setPixelFormat(RX_FMT_GRAY8);
      break;
    }
    case PNG_COLOR_TYPE_RGB: {
      img.setPixelFormat(RX_FMT_RGB24);
      break;
    }
    case PNG_COLOR_TYPE_RGB_ALPHA: {
      img.setPixelFormat(RX_FMT_RGBA32);
      break;
    }
    default: {
      RX_ERROR(PNG_ERR_UNSUPPORTED_FORMAT);
      return false;
    }
  }

  img.setWidth(png.getWidth());
  img.setHeight(png.getHeight());

  return img.copyPixels(png.getPixels(), png.getWidth(), png.getHeight(), img.getPixelFormat());
}