C++ PNG::resize方法代码示例

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;
}

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;
}

int main()
{
    const int rectangle_width = 16;
    const int rectangle_height = 16;
    Vector2 rectangle_center(32, 16);
    // I can create a Rectangle using a Rectangle Pointer!
    Rectangle* rectangle = new Rectangle(rectangle_center, color::RED,
                                         rectangle_width, rectangle_height);

    rectangle_center.set_x(rectangle_center.x() + rectangle_width);
    // OR I can create a Rectangle using a Shape Pointer!!
    Shape* rectangle_shape = new Rectangle(rectangle_center, color::ORANGE,
                                           rectangle_width, rectangle_height);

    rectangle_center.set_x(rectangle_center.x() + rectangle_width);
    // OR I can create a Rectangle using a Drawable Pointer!!!
    Drawable* rectangle_drawable = new Rectangle(
        rectangle_center, color::YELLOW, rectangle_width, rectangle_height);

    // Since all these pointers point to something that is a Drawable type
    // lets make an array of drawable pointers
    size_t num_drawables = 3;
    Drawable** drawables = new Drawable*[num_drawables];
    drawables[0] = rectangle;
    drawables[1] = rectangle_shape;
    drawables[2] = rectangle_drawable;

    PNG canvas;
    canvas.resize(WIDTH, HEIGHT);

    // Since they are all drawable I can call draw on all of them
    for (size_t i = 0; i < num_drawables; i++) {
        drawables[i]->draw(&canvas);
    }

    canvas.writeToFile(OUTPUT_FILE);

    for (size_t i = 0; i < num_drawables; i++) {
        delete drawables[i];
        drawables[i] = NULL;
    }

    delete[] drawables;
    drawables = NULL;
    return 0;
}

PNG testColorPicker(colorPicker & picker) {
	PNG img;
	img.resize(FUNCTORTESTWIDTH, FUNCTORTESTHEIGHT);
	RGBAPixel px;

	for(int x = 1; x < FUNCTORTESTWIDTH; x = x + x)
	{
		for(int y = 1; y < FUNCTORTESTHEIGHT; y = y + y) {
			px = picker(x, y);
			cout << "\toperator()(" << x << ", " << y << ") = {" << (int)px.red << ", ";
			cout << (int)px.green << ", " << (int)px.blue << "}" << endl;
		}
	}

	for(int x = 0; x < FUNCTORTESTWIDTH; x++)
		for(int y = 0; y < FUNCTORTESTHEIGHT; y++)
			*img(x, y) = picker(x, y);

	return img;
}