int* SharpenFilter::highBoostSharpen() {
	int boostFactor = 1;
	int *blurPixels = new int[width * height];
	memcpy(blurPixels, pixels, width * height * sizeof(int));

	AverageSmoothFilter *smoothFilter = new AverageSmoothFilter(blurPixels, width, height);
	blurPixels = smoothFilter->procImage();

	int *edgePixels = new int[width * height];
	for (int i = 0; i < width * height; i++) {
		Color pixColor(pixels[i]);
		Color blurColor(blurPixels[i]);
		int edgeR = min(255, max(0, pixColor.R() - blurColor.R()));
		int edgeG = min(255, max(0, pixColor.G() - blurColor.G()));
		int edgeB = min(255, max(0, pixColor.B() - blurColor.B()));
		edgePixels[i] = RGB2Color(edgeR, edgeG, edgeB);
	}

	for (int i = 0; i < width * height; i++) {
		Color pixColor(pixels[i]);
		Color edgeColor(edgePixels[i]);
		int r = min(255, max(0, pixColor.R() + boostFactor * edgeColor.R()));
		int g = min(255, max(0, pixColor.G() + boostFactor * edgeColor.G()));
		int b = min(255, max(0, pixColor.B() + boostFactor * edgeColor.B()));
		pixels[i] = RGB2Color(r, g, b);
	}

	delete smoothFilter;
	delete [] edgePixels;

	return pixels;
}
Пример #2
0
int* SketchFilter::procImage() {
	changeImageToGray(pixels, width, height);

	int *originPixels = new int[width * height];
	memcpy(originPixels, pixels, width * height * sizeof(int));

	int threshold = 7;
	for (int i = 1; i < height - 1; i++) {
		for (int j = 1; j < width - 1; j++) {
			Color centerColor(originPixels[i * width + j]);
			int centerGray = centerColor.R();

			int rightBottomIndex = (i + 1) * width + j + 1;
			if (rightBottomIndex < width * height) {
				Color rightBottomColor(originPixels[rightBottomIndex]);
				int rightBottomGray = rightBottomColor.R();
				if (abs(centerGray - rightBottomGray) >= threshold) {
					pixels[i * width + j] = RGB2Color(0, 0, 0); // black
				} else {
					pixels[i * width + j] = RGB2Color(255, 255, 255); // white
				}
			}

		}
	}

	delete[] originPixels;

	return pixels;
}
int* SharpenFilter::procImage() {
	int pixR, pixG, pixB, newR, newG, newB, index;
	int laplacian[] = {0, -1, 0, -1, 4, -1, 0, -1, 0}; // 3 * 3 laplacian
	int maskSize = 3;
	int halfMaskSize = maskSize / 2;

	int *edgePixels = new int[width * height];
	memset(edgePixels, 0, width * height * sizeof(int));

	for (int i = halfMaskSize; i < height - halfMaskSize; i++)  {
		for (int k = halfMaskSize; k < width - halfMaskSize; k++)  {
			index = 0;
			newR = newG = newB = 0;
			for (int m = -halfMaskSize; m <= halfMaskSize; m++) {
				for (int n = -halfMaskSize; n <= halfMaskSize; n++) {

					Color pixColor(pixels[(i + n) * width + k + m]);
					pixR = pixColor.R();
					pixG = pixColor.G();
					pixB = pixColor.B();

					newR += pixR * laplacian[index];
					newG += pixG * laplacian[index];
					newB += pixB * laplacian[index];
					index++;
				}
			}

			newR = min(255, max(0, newR));
			newG = min(255, max(0, newG));
			newB = min(255, max(0, newB));

			edgePixels[i * width + k] = RGB2Color(newR, newG, newB);
		}
	}

	for (int i = 0; i < width * height; i++) {
		Color edgeColor(edgePixels[i]);
		Color originColor(pixels[i]);

		int r = min(255, max(0, edgeColor.R() + originColor.R()));
		int g = min(255, max(0, edgeColor.G() + originColor.G()));
		int b = min(255, max(0, edgeColor.B() + originColor.B()));

		pixels[i] = RGB2Color(r, g, b);
	}

	delete [] edgePixels;
	return pixels;
}
int* AverageSmoothFilter::procImage() {
	int sumR = 0;
	int sumG = 0;
	int sumB = 0;
	int div = maskSize * maskSize;
	int halfMaskSize = maskSize / 2;

	for (int row = halfMaskSize; row < height - halfMaskSize; row++) {
		for (int col = halfMaskSize; col < width - halfMaskSize; col++) {
			sumR = sumG = sumB = 0;
			for (int m = -halfMaskSize; m <= halfMaskSize; m++) {
				for (int n = -halfMaskSize; n <= halfMaskSize; n++) {
					int index = (row + m) * width + col + n;
					if (index < width * height) {
						Color color(pixels[(row + m) * width + col + n]);
						sumR += color.R();
						sumG += color.G();
						sumB += color.B();
					}
				}
			}
			pixels[row * width + col] = RGB2Color(sumR / div, sumG / div, sumB / div);
		}
	}

	return this->pixels;
}
int* HueSaturationFilter::setHueSaturationIntesity(double hue, double saturation, double intensity) {
	for (int i = 0; i < width * height; i++) {
		HSI hsi = pixelsHSI[i];
		double h = hsi.h;
		h = hue;
		if (h > 360) {
			h = h - 360;
		} else if (h < 0) {
			h = h + 360;
		}

		double s = hsi.s;
		s = saturation;
		s = min(1.0, max(0.0, s));

		double newI = hsi.i;
		newI = intensity;
		newI = min(1.0, max(0.0, newI));

		pixelsHSI[i] = HSI(h, s, newI);
		RGB rgb = ColorTranslator::HSI2RGB(h, s, hsi.i);
		if (ColorTranslator::checkRGB(rgb)) {
			pixels[i] = RGB2Color(rgb.r, rgb.g, rgb.b);
		}
	}
	return pixels;
}
int* GammaCorrectionFilter::procImage() {
	for (int i = 0; i < width * height; i++) {
		Color color(pixels[i]);
		int r = gammaTable[color.R()];
		int g = gammaTable[color.G()];
		int b = gammaTable[color.B()];
		pixels[i] = RGB2Color(r, g, b);
	}
	return pixels;
}
Пример #7
0
int* TvFilter::procImage() {
	int r, g, b;
	for (int x = 0; x < width; x++) {
		for (int y = 0; y < height; y += gap) {
			r = g = b = 0;

			for (int w = 0; w < 4; w++) {
				int index = (y + w) * width + x;
				if (index < width * height) {
					Color color(pixels[index]);
					r += color.R() / gap;
					g += color.G() / gap;
					b += color.B() / gap;
				}
			}
			r = min(255, max(0, r));
			g = min(255, max(0, g));
			b = min(255, min(0, b));

			for (int w = 0; w < gap; w++) {
				int index = (y + w) * width + x;
				if (index < width * height) {
					if (w == 0) {
						pixels[(y + w) * width + x] = RGB2Color(r, 0, 0);
					}
					if (w == 1) {
						pixels[(y + w) * width + x] = RGB2Color(0, g, 0);
					}
					if (w == 2) {
						pixels[(y + w) * width + x] = RGB2Color(0, 0, b);
					}
//					if (w == 3) {
//						pixels[(y + w) * width + x] = RGB2Color(r, 0, 0);
//					}
				}
			}
		}
	}
	return pixels;
}
int* HueSaturationFilter::setSaturation(double saturation) {
	for (int i = 0; i < width * height; i++) {
		HSI hsi = pixelsHSI[i];
		double s = hsi.s;
		s = saturation;
		s = min(1.0, max(0.0, s));
		pixelsHSI[i] = HSI(hsi.h, s, hsi.i);
		RGB rgb = ColorTranslator::HSI2RGB(hsi.h, s, hsi.i);
		if (ColorTranslator::checkRGB(rgb)) {
			pixels[i] = RGB2Color(rgb.r, rgb.g, rgb.b);
		}
	}
	return pixels;
}
int* GaussianBlurFilter::procImage() {
	if (maskSize == 1) {
		return NULL;
	}
	int* tempPixels = new int[width * height];
	memcpy(tempPixels, pixels, width * height * sizeof(int));

	double sumR = 0, sumG = 0, sumB = 0;
	int index = 0;
	int bound = maskSize / 2;

	long startTime = getCurrentTime();

	for (int row = bound; row < height - bound; row++) {
		for (int col = bound; col < width - bound; col++) {
			index = 0;
			sumR = sumG = sumB = 0;
			for (int i = -bound; i <= bound; i++) {
				for (int j = -bound; j <= bound; j++) {
					int pixel_index = (row + i) * width + col + j;
					if (pixel_index < width * height) {
						Color color(tempPixels[pixel_index]);
						sumR += color.R() * kernel[index];
						sumG += color.G() * kernel[index];
						sumB += color.B() * kernel[index];
						index++;
					}

				}
			}

			pixels[row * width + col] = RGB2Color(int(sumR), int(sumG), int(sumB));
		}
	}

	long endTime = getCurrentTime();

	LOGI("guassian blur use %ld ms, maskSize: %d, sigma: %f", endTime - startTime, maskSize, sigma);

	delete [] tempPixels;

	return this->pixels;
}
int* HueSaturationFilter::setHue(double hue) {
	for (int i = 0; i < width * height; i++) {
		HSI hsi = pixelsHSI[i];
		double h = hsi.h;
		h = hue;
		//h = min(360.0, max(0.0, h));
		if (h > 360) {
			h = h - 360;
		} else if (h < 0) {
			h = h + 360;
		}
		pixelsHSI[i] = HSI(h, hsi.s, hsi.i);
		RGB rgb = ColorTranslator::HSI2RGB(h, hsi.s, hsi.i);
		if (ColorTranslator::checkRGB(rgb)) {
			pixels[i] = RGB2Color(rgb.r, rgb.g, rgb.b);
		}
	}
	return pixels;
}
Пример #11
0
int* OilFilter::procImage() {
	int *originPixels = new int[width * height];
	memcpy(originPixels, pixels, width * height * sizeof(int));

	int rHis[OIL_FILTER_LEVEL], gHis[OIL_FILTER_LEVEL], bHis[OIL_FILTER_LEVEL];

	for (int y = 0; y < height; y++) {
		for (int x = 0; x < width; x++) {
			memset(rHis, 0, OIL_FILTER_LEVEL * sizeof(int));
			memset(gHis, 0, OIL_FILTER_LEVEL * sizeof(int));
			memset(bHis, 0, OIL_FILTER_LEVEL * sizeof(int));

			int rowOffset, colOffset;
			for (int row = -this->oilRange; row < this->oilRange; row++) {
				rowOffset = y + row;
				if (rowOffset >= 0 && rowOffset < height) {
					for (int col = -this->oilRange; col < this->oilRange; col++) {
						colOffset = x + col;
						if (colOffset >= 0 && colOffset < width) {
							Color color = originPixels[rowOffset * width + colOffset];
							int r = color.R();
							int g = color.G();
							int b = color.B();

							rHis[r]++;
							gHis[g]++;
							bHis[b]++;
						}
					}
				}
			}

			int maxR = 0, maxG = 0, maxB = 0;
			for (int i = 1; i < OIL_FILTER_LEVEL; i++) {
				if (rHis[i] > rHis[maxR]) {
					maxR = i;
				}
				if (gHis[i] > gHis[maxG]) {
					maxG = i;
				}
				if (bHis[i] > bHis[maxB]) {
					maxB = i;
				}
			}
			if (rHis[maxR] != 0 && gHis[maxG] != 0 && bHis[maxB] != 0) {
				int finalR = maxR;
				int finalG = maxG;
				int finalB = maxB;

				finalR = min(255, max(0, finalR));
				finalG = min(255, max(0, finalG));
				finalB = min(255, max(0, finalB));

				pixels[y * width + x] = RGB2Color(finalR, finalG, finalB);
			}
		}
	}

	delete [] originPixels;

	return pixels;
}