예제 #1
0
void TAM::drawStroke(Image* strokeImage, RandomStroke strokeModifiers, Image* dest){
    Image* scaledImage = ip_scale(strokeImage, strokeModifiers.length, 1);
    Image* rotImage = ip_rotate(scaledImage, strokeModifiers.rot);
    
    if (!strokeModifiers.horizontal) {
        Image* old = rotImage;
        rotImage = rotate_90(rotImage);
        delete old;
    }
    
    ip_composite(dest, rotImage, strokeModifiers.x*dest->getWidth(), strokeModifiers.y*dest->getHeight());
    delete scaledImage;
    delete rotImage;
}
예제 #2
0
void process_func (int value)
{

	Image* resultImage = NULL;
	static int samplingMode = I_NEAREST;
	static int gaussianFilterSize = 3;
	static double gaussianSigma = 1.0;

	//  check if we have an image to process 
	if (!currentImage)
	{
		cerr << "Sorry, no image is loaded!" << endl;
		return;
	}

	switch (value)
	{
	case M_PROCESS_BLUR_BOX:  // enum #6
		{
			int filterSize = getFilterSize();
			if (filterSize>0)
				resultImage = ip_blur_box(currentImage, filterSize);
			break;
		}


	case M_PROCESS_BLUR_GAUSSIAN:  // enum #7
		{
			int filterSize = getFilterSize();
			if (filterSize<=0)
				break;
			double sigma = getPositiveDouble("sigma");
			if (sigma>0)
				resultImage = ip_blur_gaussian(currentImage, filterSize, sigma);
			break;
		}


	case M_PROCESS_BLUR_TRIANGLE:  // enum #8
		{
			int filterSize = getFilterSize();
			if (filterSize>0)
				resultImage = ip_blur_triangle(currentImage, filterSize);
			break;
		}


	case M_PROCESS_BRIGHTEN:  // enum #9
		{
			double alpha = getDouble("alpha");
			resultImage = ip_brighten(currentImage, alpha);
			break;
		}

	case M_PROCESS_COLOR_SHIFT: // enum #10
		resultImage=ip_color_shift(currentImage);
		break;

	case M_PROCESS_CONTRAST:  // enum #11
		{
			double alpha=getDouble("alpha");
			resultImage = ip_contrast(currentImage, alpha);
			break;
		}


	case M_PROCESS_COMPOSITE: // enum #12
		{
			char filename[MAX_NAME];
			// we don't do a lot of checks here; i.e. second image and
			// mask valid images and the same size as current image
			if (!quietMode)
				cerr << "Enter filename of second image (string - no spaces) : ";
			cin  >> filename;
			Image* secondImage = new Image();
			secondImage->read(filename);
			if (!quietMode)
				cerr << "Enter filename of mask (string - no spaces) : ";
			cin  >> filename;
			Image* mask = new Image();
			mask->read(filename);
			checkStream(cin);
			resultImage = ip_composite(currentImage, secondImage, mask);
			delete secondImage;
			delete mask;
			break;
		}


	case M_PROCESS_CROP: // enum #13
		{
			int x0, y0, x1, y1;
			if (!quietMode)
			{
				cerr << "Current image width and height: " << currentImage->getWidth()-1 << " " 
					<< currentImage->getHeight()-1 << endl;
				cerr << "Enter region to crop (left top right bottom (ints)) : ";
			}
			cin >> x0 >> y0 >> x1 >> y1;
			checkStream(cin);
			if (x0>=0 || x0<x1 || x1<currentImage->getWidth() || y0>=0 || y0<y1 || y1<currentImage->getHeight())
			{
				resultImage = ip_crop(currentImage, x0,y0,x1,y1);
			}
			else
			{
				cerr<< "Invalid region." << endl;
			}

			break;
		}


	case M_PROCESS_EDGE_DETECT: // enum #14
		resultImage = ip_edge_detect(currentImage);
		break;


	case M_PROCESS_EXTRACT:  // enum #15
		{
			int channel = getInt("channel [0,2]");
			if (channel<0 || channel>2) 
			{
				cerr << "Invalid channel."<< endl;
			}
			else
			{
				resultImage = ip_extract(currentImage, channel);
			}
			break;
		}

	case M_PROCESS_FUN_WARP:  // enum #16
		resultImage = ip_fun_warp(currentImage,samplingMode);
		break;

	case M_PROCESS_GREY: // enum #17
		resultImage = ip_grey(currentImage);
		break;

	case M_PROCESS_IMAGE_SHIFT: // enum #18
		{
			double dx = getDouble("dx");
			double dy = getDouble("dy");
			resultImage = ip_image_shift(currentImage,dx, dy);
			break;
		}

	case M_PROCESS_INVERT:  // enum #19
		resultImage = ip_invert(currentImage);
		break;

	case M_PROCESS_MISC: // enum #20
		resultImage = ip_misc(currentImage);
		break;


	case M_PROCESS_QUANTIZE_SIMPLE:  // enum #21
		{

			int bitsPerChannel = getInt("bits per channel [1,8]");
			if (bitsPerChannel<=0 || bitsPerChannel>8)
			{
				cerr << "Invalid number bits." << endl;
			}
			else
			{
				resultImage = ip_quantize_simple(currentImage, bitsPerChannel);
			}
			break;
		}


	case M_PROCESS_QUANTIZE_ORDERED:  //enum #22
		{
			int bitsPerChannel = getInt("bits per channel [1,8]");

			if (bitsPerChannel<=0 || bitsPerChannel>8)
			{
				cerr << "Invalid number bits." << endl;
			}
			else
			{
				resultImage = ip_quantize_ordered(currentImage, bitsPerChannel);
			}
			break;
		}


	case M_PROCESS_QUANTIZE_FLOYD_STEINBERG: // enum #23
		{
			int bitsPerChannel = getInt("bits per channel [1,8]");

			if (bitsPerChannel<=0 || bitsPerChannel>8)
			{
				cerr << "Invalid number bits." << endl;
			}
			else
			{
				resultImage = ip_quantize_fs(currentImage, bitsPerChannel);
			}
			break;
		}


	case M_PROCESS_ROTATE: // enum #24
		{
			if (!quietMode) 
			{
				cerr<< "Current image width/height: " << currentImage->getWidth()-1 << " " 
					<< currentImage->getHeight()-1 << endl;
			}
			double theta = getDouble("angle");
			double x = getDouble("point x");
			double y = getDouble("point y");
			resultImage = ip_rotate(currentImage, theta, x, y, samplingMode, 
				gaussianFilterSize, gaussianSigma);
			break;
		}


	case M_PROCESS_SATURATE:  // enum #25
		{
			double alpha = getDouble("alpha");
			resultImage = ip_saturate(currentImage, alpha);
			break;
		}


	case M_PROCESS_SCALE: // enum #26
		{
			double xFactor = getDouble("scale factor for x");
			double yFactor = getDouble("scale factor for y");
			resultImage = ip_scale(currentImage, xFactor, yFactor, samplingMode, gaussianFilterSize, gaussianSigma);
			break;
		}

	case M_PROCESS_SET_SAMPLING_BILINEAR: // enum #27
		samplingMode=I_BILINEAR;
		break;

	case M_PROCESS_SET_SAMPLING_NEAREST:  // enum #28
		samplingMode=I_NEAREST;
		break;

	case M_PROCESS_SET_SAMPLING_GAUSSIAN: // enum #29
		gaussianFilterSize=getInt("filter size (positive, even integer)");
		if (gaussianFilterSize%2!=0 || gaussianFilterSize<=0)
		{
			gaussianFilterSize=3;
			cerr<<"Invalid value, using default size of 3"<<endl;
		}
		gaussianSigma=getDouble("sigma (non-negative)");
		if (gaussianSigma <0) 
		{
			gaussianSigma=1;
			cerr<<"Invalid value, using default sigma of 1"<<endl;
		}
		samplingMode=I_GAUSSIAN;
        break;

	case M_PROCESS_THRESHOLD: // enum #23
		{
			double threshold=getDouble("threshold [0,1]");
			resultImage = ip_threshold(currentImage, threshold);
			break;
		}


	default:
		break;
	}

	if (resultImage != NULL)
	{
		delete currentImage;
		currentImage = resultImage;

		if (currentImage->getWidth()  != window_width    ||
			currentImage->getHeight() != window_height)
			reshape(currentImage->getWidth(), currentImage->getHeight());

		if (!quietMode)
			cerr << "done!" << endl;

		if (!textMode)
			glutPostRedisplay();
	}
}