void removeIslands(ofPixels_<T>& img) { int w = img.getWidth(), h = img.getHeight(); int ia1=-w-1,ia2=-w-0,ia3=-w+1,ib1=-0-1,ib3=-0+1,ic1=+w-1,ic2=+w-0,ic3=+w+1; T* p = img.getPixels(); for(int y = 1; y + 1 < h; y++) { for(int x = 1; x + 1 < w; x++) { int i = y * w + x; if(p[i]) { if(!p[i+ia1]&&!p[i+ia2]&&!p[i+ia3]&&!p[i+ib1]&&!p[i+ib3]&&!p[i+ic1]&&!p[i+ic2]&&!p[i+ic3]) { p[i] = 0; } } } } }
bool ofPixels_<PixelType>::pasteInto(ofPixels_<PixelType> &dst, int xTo, int yTo){ if (!(isAllocated()) || !(dst.isAllocated()) || getBytesPerPixel() != dst.getBytesPerPixel() || xTo>=dst.getWidth() || yTo>=dst.getHeight()) return false; int bytesToCopyPerRow = (xTo + getWidth()<=dst.getWidth() ? getWidth() : dst.getWidth()-xTo) * getBytesPerPixel(); int columnsToCopy = yTo + getHeight() <= dst.getHeight() ? getHeight() : dst.getHeight()-yTo; PixelType * dstPix = dst.getPixels() + ((xTo + yTo*dst.getWidth())*dst.getBytesPerPixel()); PixelType * srcPix = getPixels(); int srcStride = getWidth()*getBytesPerPixel(); int dstStride = dst.getWidth()*dst.getBytesPerPixel(); for(int y=0;y<columnsToCopy; y++){ memcpy(dstPix,srcPix,bytesToCopyPerRow); dstPix += dstStride; srcPix += srcStride; } return true; }
void ofImage_<PixelType>::setFromPixels(const ofPixels_<PixelType> & pixels){ setFromPixels(pixels.getPixels(),pixels.getWidth(),pixels.getHeight(),pixels.getImageType()); }
bool ofPixels_<PixelType>::resizeTo(ofPixels_<PixelType>& dst, ofInterpolationMethod interpMethod){ if (!(isAllocated()) || !(dst.isAllocated()) || getBytesPerPixel() != dst.getBytesPerPixel()) return false; int srcWidth = getWidth(); int srcHeight = getHeight(); int dstWidth = dst.getWidth(); int dstHeight = dst.getHeight(); int bytesPerPixel = getBytesPerPixel(); PixelType * dstPixels = dst.getPixels(); switch (interpMethod){ //---------------------------------------- case OF_INTERPOLATE_NEAREST_NEIGHBOR:{ int dstIndex = 0; float srcxFactor = (float)srcWidth/dstWidth; float srcyFactor = (float)srcHeight/dstHeight; float srcy = 0.5; for (int dsty=0; dsty<dstHeight; dsty++){ float srcx = 0.5; int srcIndex = int(srcy)*srcWidth; for (int dstx=0; dstx<dstWidth; dstx++){ int pixelIndex = int(srcIndex + srcx) * bytesPerPixel; for (int k=0; k<bytesPerPixel; k++){ dstPixels[dstIndex] = pixels[pixelIndex]; dstIndex++; pixelIndex++; } srcx+=srcxFactor; } srcy+=srcyFactor; } }break; //---------------------------------------- case OF_INTERPOLATE_BILINEAR: // not implemented yet ofLogError(" Bilinear resize not implemented "); break; //---------------------------------------- case OF_INTERPOLATE_BICUBIC: float px1, py1; float px2, py2; float px3, py3; float srcColor = 0; float interpCol; int patchRow; int patchIndex; float patch[16]; int srcRowBytes = srcWidth*bytesPerPixel; int loIndex = (srcRowBytes)+1; int hiIndex = (srcWidth*srcHeight*bytesPerPixel)-(srcRowBytes)-1; for (int dsty=0; dsty<dstHeight; dsty++){ for (int dstx=0; dstx<dstWidth; dstx++){ int dstIndex0 = (dsty*dstWidth + dstx) * bytesPerPixel; float srcxf = srcWidth * (float)dstx/(float)dstWidth; float srcyf = srcHeight * (float)dsty/(float)dstHeight; int srcx = (int) MIN(srcWidth-1, srcxf); int srcy = (int) MIN(srcHeight-1, srcyf); int srcIndex0 = (srcy*srcWidth + srcx) * bytesPerPixel; px1 = srcxf - srcx; py1 = srcyf - srcy; px2 = px1 * px1; px3 = px2 * px1; py2 = py1 * py1; py3 = py2 * py1; for (int k=0; k<bytesPerPixel; k++){ int dstIndex = dstIndex0+k; int srcIndex = srcIndex0+k; for (int dy=0; dy<4; dy++) { patchRow = srcIndex + ((dy-1)*srcRowBytes); for (int dx=0; dx<4; dx++) { patchIndex = patchRow + (dx-1)*bytesPerPixel; if ((patchIndex >= loIndex) && (patchIndex < hiIndex)) { srcColor = pixels[patchIndex]; } patch[dx*4 + dy] = srcColor; } } interpCol = (PixelType)bicubicInterpolate(patch, px1,py1, px2,py2, px3,py3); dstPixels[dstIndex] = interpCol; } } } break; } return true; }
void ofPixels_<PixelType>::copyFrom(const ofPixels_<PixelType> & mom){ if(mom.isAllocated()) { allocate(mom.getWidth(), mom.getHeight(), mom.getNumChannels()); memcpy(pixels, mom.getPixels(), mom.getWidth() * mom.getHeight() * mom.getBytesPerPixel()); } }
void ofPixels_<PixelType>::rotate90To(ofPixels_<PixelType> & dst, int nClockwiseRotations) const{ int channels = channelsFromPixelFormat(pixelFormat); if (bAllocated == false || channels==0){ return; } if(&dst == this){ dst.rotate90(nClockwiseRotations); return; } // first, figure out which type of rotation we have int rotation = nClockwiseRotations; while (rotation < 0){ rotation+=4; } rotation %= 4; // if it's 0, just make a copy. if it's 2, do it by a mirror operation. if (rotation == 0) { dst = *this; return; // do nothing! } else if (rotation == 2) { mirrorTo(dst, true, true); return; } // otherwise, we will need to do some new allocaiton. dst.allocate(height,width,getImageType()); int strideSrc = width * channels; int strideDst = dst.width * channels; if(rotation == 1){ PixelType * srcPixels = pixels; PixelType * startPixels = dst.getPixels() + (strideDst - channels); for (int i = 0; i < height; ++i, --startPixels){ PixelType * dstPixels = startPixels; for (int j = 0; j < width; ++j){ for (int k = 0; k < channels; ++k){ dstPixels[k] = srcPixels[k]; } srcPixels += channels; dstPixels += strideDst; } } } else if(rotation == 3){ PixelType * dstPixels = dst.pixels; PixelType * startPixels = pixels + (strideSrc - channels); for (int i = 0; i < dst.height; ++i, --startPixels){ PixelType * srcPixels = startPixels; for (int j = 0; j < dst.width; ++j){ for (int k = 0; k < channels; ++k){ dstPixels[k] = srcPixels[k]; } srcPixels += strideSrc; dstPixels += channels; } } } }
void ofPixels_<PixelType>::copyFrom(const ofPixels_<PixelType> & mom){ if(mom.isAllocated()) { allocate(mom.getWidth(), mom.getHeight(), mom.getPixelFormat()); memcpy(pixels, mom.getPixels(), mom.size() * sizeof(PixelType)); } }