public Tracker90mmDish(int imageWidth, int imageHeight) { _foreground = new Image8(imageWidth, imageHeight); _calc = new Image8(imageWidth, imageHeight); _labelMarkers = new Image8(imageWidth, imageHeight); int bufferSize = 0; IppHelper.IppCheckCall(cv.ippiLabelMarkersGetBufferSize_8u_C1R(new IppiSize(imageWidth, imageHeight), &bufferSize)); _markerBuffer = (byte *)Marshal.AllocHGlobal(bufferSize); fixed(IppiMomentState_64s **ppState = &_momentState) { //let ipp decide whether to give accurate or fast results IppHelper.IppCheckCall(ip.ippiMomentInitAlloc_64s(ppState, IppHintAlgorithm.ippAlgHintNone)); } _frame = 0; //populate tracking parameters with default values _threshold = 5; _minArea = 10; _maxArea = 300; _fullTrustMinArea = 20; _imageROI = new IppiROI(0, 0, imageWidth, imageHeight); //The following calculation for FramesInBackground means that after ~30s of movie //a stationary object will have dissappeared into the background (at 63% level) FramesInBackground = (int)((30 * 240)); FramesInitialBackground = 2 * FramesInBackground; }
public Tracker90mmDish(int imageWidth, int imageHeight, IppiPoint dishCenter) { _foreground = new Image8(imageWidth, imageHeight); _bgSubtracted = new Image8(imageWidth, imageHeight); _calc = new Image8(imageWidth, imageHeight); _dishCenter = dishCenter; int bufferSize = 0; IppHelper.IppCheckCall(cv.ippiLabelMarkersGetBufferSize_8u_C1R(new IppiSize(imageWidth, imageHeight), &bufferSize)); _markerBuffer = (byte *)Marshal.AllocHGlobal(bufferSize); int momentSize = 0; IppHelper.IppCheckCall(ip.ippiMomentGetStateSize_64f(IppHintAlgorithm.ippAlgHintNone, &momentSize)); _momentState = (IppiMomentState_64f *)Marshal.AllocHGlobal(momentSize); //let ipp decide whether to give accurate or fast results IppHelper.IppCheckCall(ip.ippiMomentInit_64f(_momentState, IppHintAlgorithm.ippAlgHintNone)); _frame = 0; //populate tracking parameters with default values _threshold = 6; _minArea = 11; _maxAllowedArea = 120; _minEccentricity = 0.3; _fullTrustMinArea = 20; _imageROI = new IppiROI(0, 0, imageWidth, imageHeight); _searchRegionSize = 90; _removeCMOSISBrightLineArtefact = false; _strel3x3 = Morphology.Generate3x3Mask(_foreground.Size); //The following calculation for FramesInBackground means that after ~30s of movie //a stationary object will have dissappeared into the background (at 63% level) FramesInBackground = (int)((30 * 250)); FramesInitialBackground = 2 * 30 * 250; BGUpdateEvery = 2; }
/// <summary> /// Creates a new BLIScanLookup Table which is prefilled /// with previously obtained point-voltage relationships /// </summary> /// <param name="xVolts">The 2D table of x-Voltages</param> /// <param name="yVolts">The 2D table of y-Voltages</param> /// <param name="scanRoi">The image ROI of the coordinates</param> /// <param name="spacing">The spacing between the interpolation anchors stored in the table</param> public BLIScanLookupTable(float[] xVolts, float[] yVolts, IppiROI scanRoi, int spacing = 8) { if (xVolts.Length != yVolts.Length) { throw new ArgumentException("The two voltage lookup tables must have the same number of elements"); } _c = (int)Math.Floor((float)scanRoi.Width / spacing) + 1; _r = (int)Math.Floor((float)scanRoi.Height / spacing) + 1; if (xVolts.Length != _c * _r) { throw new ArgumentException("The supplied voltage tables don't match with the image/border/spacing dimensions"); } _spacing = spacing; _xVolts = xVolts; _yVolts = yVolts; _complete = true; _addIndex = _c * _r; _scanRoi = scanRoi; }
/// <summary> /// Creates a new empty BLIScanLookupTable /// </summary> /// <param name="scanRoi">The image ROI in which to compute coordinates</param> /// <param name="spacing">The spacing between the interpolation anchors stored in the table</param> public BLIScanLookupTable(IppiROI scanRoi, int spacing = 8) { //validate dimensions in relation to spacing if (scanRoi.Width % spacing != 0) { throw new ArgumentException("The ROI width has to be dividable by the spacing"); } if (scanRoi.Height % spacing != 0) { throw new ArgumentException("The ROI height has to be dividable by the spacing"); } _spacing = spacing; //initialize arrays _c = (int)Math.Floor((float)scanRoi.Width / _spacing) + 1; _r = (int)Math.Floor((float)scanRoi.Height / spacing) + 1; _xVolts = new float[_c * _r]; _yVolts = new float[_c * _r]; _addIndex = -1; _scanRoi = scanRoi; }
/// <summary> /// Differences the current image with the previous one and computes the number of pixels /// above the set difference threshold in the selected ROI /// </summary> /// <param name="imCurrent">The current frame to difference with the previous</param> /// <param name="roi">The ROI in which to perform the compuation</param> /// <returns>Number of pixels above threshold in the delta frame</returns> public int ComputeNumDeltaPixels(Image8 imCurrent, IppiROI roi) { double nPixels = 0; if (!_isFirst) { //form difference image cv.ippiAbsDiff_8u_C1R(imCurrent[roi.TopLeft], imCurrent.Stride, _imPrevious[roi.TopLeft], _imPrevious.Stride, _imDelta[roi.TopLeft], _imDelta.Stride, roi.Size); //threshold image BWImageProcessor.Im2Bw(_imDelta, _imThresh, roi, _threshold); //count pixels ip.ippiSum_8u_C1R(_imThresh[roi.TopLeft], _imThresh.Stride, roi.Size, &nPixels); } else { _isFirst = false; } //copy current image to previous image buffer ip.ippiCopy_8u_C1R(imCurrent[roi.TopLeft], imCurrent.Stride, _imPrevious[roi.TopLeft], _imPrevious.Stride, roi.Size); //return pixel count - divide sum by 255 since threshold sets al values to 255 return((int)nPixels / 255); }
/// <summary> /// Extracts a fish (candidate) from an image by performing background subtraction, noise filtering, thresholding and closing to obtain a foreground /// followed by marker extraction. /// </summary> /// <param name="im">The image to extract the fish from</param> /// <param name="region">The ROI to search</param> /// <returns>The most likely fish blob or null if no suitable candidate was found</returns> protected BlobWithMoments ExtractFish(/*Image8 im,*/ IppiROI region) { int nMarkers = 0; BlobWithMoments[] blobsDetected; //Copy foreground to marker and label connected components //IppHelper.IppCheckCall(ip.ippiCopy_8u_C1R(_foreground[region.TopLeft], _foreground.Stride, _labelMarkers[region.TopLeft], _labelMarkers.Stride, region.Size)); IppHelper.IppCheckCall(cv.ippiLabelMarkers_8u_C1IR(_foreground[region.TopLeft], _foreground.Stride, region.Size, 1, 254, IppiNorm.ippiNormInf, &nMarkers, _markerBuffer)); //loop over returned markers and use ipp to extract blobs if (nMarkers > 0) { if (nMarkers > 254) { nMarkers = 254; } blobsDetected = new BlobWithMoments[nMarkers]; for (int i = 1; i <= nMarkers; i++) { //label all pixels with the current marker as 255 and others as 0 IppHelper.IppCheckCall(ip.ippiCompareC_8u_C1R(_foreground[region.TopLeft], _foreground.Stride, (byte)i, _calc[region.TopLeft], _calc.Stride, region.Size, IppCmpOp.ippCmpEq)); //calculate image moments IppHelper.IppCheckCall(ip.ippiMoments64s_8u_C1R(_calc[region.TopLeft], _calc.Stride, region.Size, _momentState)); //retrieve moments long m00 = 0; long m10 = 0; long m01 = 0; long m20 = 0; long m02 = 0; long m11 = 0; long m30 = 0; long m03 = 0; long m21 = 0; long m12 = 0; ip.ippiGetSpatialMoment_64s(_momentState, 0, 0, 0, new IppiPoint(region.X, region.Y), &m00, 0); //since our input image is not 0s and 1s but 0s and 255s we have to divide by 255 in order to re-normalize our moments System.Diagnostics.Debug.Assert(m00 % 255 == 0, "M00 was not a multiple of 255"); m00 /= 255; //only retrieve other moments if this is a "fish candidate" if (m00 > MinArea && m00 <= MaxArea) { ip.ippiGetSpatialMoment_64s(_momentState, 1, 0, 0, new IppiPoint(region.X, region.Y), &m10, 0); m10 /= 255; ip.ippiGetSpatialMoment_64s(_momentState, 0, 1, 0, new IppiPoint(region.X, region.Y), &m01, 0); m01 /= 255; ip.ippiGetSpatialMoment_64s(_momentState, 2, 0, 0, new IppiPoint(region.X, region.Y), &m20, 0); m20 /= 255; ip.ippiGetSpatialMoment_64s(_momentState, 0, 2, 0, new IppiPoint(region.X, region.Y), &m02, 0); m02 /= 255; ip.ippiGetSpatialMoment_64s(_momentState, 1, 1, 0, new IppiPoint(region.X, region.Y), &m11, 0); m11 /= 255; ip.ippiGetSpatialMoment_64s(_momentState, 3, 0, 0, new IppiPoint(region.X, region.Y), &m30, 0); m30 /= 255; ip.ippiGetSpatialMoment_64s(_momentState, 0, 3, 0, new IppiPoint(region.X, region.Y), &m03, 0); m03 /= 255; ip.ippiGetSpatialMoment_64s(_momentState, 2, 1, 0, new IppiPoint(region.X, region.Y), &m21, 0); m21 /= 255; ip.ippiGetSpatialMoment_64s(_momentState, 1, 2, 0, new IppiPoint(region.X, region.Y), &m12, 0); m12 /= 255; blobsDetected[i - 1] = new BlobWithMoments(m00, m10, m01, m20, m11, m02, m30, m03, m21, m12); //Determine bounding box of the blob. The following seems kinda retarded as Ipp must already //have obtained that information before so maybe there is some way to actually retrieve it?? //Do linescans using ipp's sum function starting from the blobs centroid until we hit a line //the sum of which is 0 int xStart, xEnd, yStart, yEnd; double sum = 1; IppiPoint centroid = blobsDetected[i - 1].Centroid; xStart = centroid.x - 5; xEnd = centroid.x + 5; yStart = centroid.y - 5; yEnd = centroid.y + 5; //in the following loops we PRE-increment, whence we stop the loop if we are at one coordinate short of the ends //find xStart while (sum > 0 && xStart > region.X + 4) { xStart -= 5; IppHelper.IppCheckCall(ip.ippiSum_8u_C1R(_calc[xStart, region.Y], _calc.Stride, new IppiSize(1, region.Height), &sum)); } xStart += 1;//we have a sum of 0, so go back one line towards the centroid //find xEnd sum = 1; while (sum > 0 && xEnd < region.X + region.Width - 6) { xEnd += 5; IppHelper.IppCheckCall(ip.ippiSum_8u_C1R(_calc[xEnd, region.Y], _calc.Stride, new IppiSize(1, region.Height), &sum)); } xEnd -= 1;//we have sum of 0, so go back one line towards the centroid //find yStart - we can limit our x-search-space as we already have those boundaries sum = 1; while (sum > 0 && yStart > region.Y + 4) { yStart -= 5; IppHelper.IppCheckCall(ip.ippiSum_8u_C1R(_calc[xStart, yStart], _calc.Stride, new IppiSize(xEnd - xStart + 1, 1), &sum)); } yStart += 1; //find yEnd - again limit summation to x-search-space sum = 1; while (sum > 0 && yEnd < region.Y + region.Height - 6) { yEnd += 5; IppHelper.IppCheckCall(ip.ippiSum_8u_C1R(_calc[xStart, yEnd], _calc.Stride, new IppiSize(xEnd - xStart + 1, 1), &sum)); } yEnd -= 1; blobsDetected[i - 1].BoundingBox = new IppiRect(xStart, yStart, xEnd - xStart + 1, yEnd - yStart + 1); } else { blobsDetected[i - 1] = new BlobWithMoments(); } } } else { return(null); } long maxArea = 0; int maxIndex = -1; for (int i = 0; i < blobsDetected.Length; i++) { if (blobsDetected[i] == null) { break; } //Simply note down the largest blob if (blobsDetected[i].Area > maxArea) { maxArea = blobsDetected[i].Area; maxIndex = i; } } if (maxArea < MinArea) { return(null); } else { return(blobsDetected[maxIndex]); } }
/// <summary> /// Performs a 3x3 closing operation on an image /// </summary> /// <param name="im">The (thresholded) image to close</param> /// <param name="region">The ROI in which to perform the operation</param> protected void Close3x3(Image8 im, IppiROI region) { IppHelper.IppCheckCall(ip.ippiDilate3x3_8u_C1IR(im[region.TopLeft.x + 1, region.TopLeft.y + 1], im.Stride, new IppiSize(region.Width - 2, region.Height - 2))); IppHelper.IppCheckCall(ip.ippiErode3x3_8u_C1IR(im[region.TopLeft.x + 1, region.TopLeft.y + 1], im.Stride, new IppiSize(region.Width - 2, region.Height - 2))); }
/// <summary> /// Implements a "greater than" threshold like MATLABS /// im2bw function /// </summary> /// <param name="im">The image to threshold</param> /// <param name="region">The ROI in which to perform the operation</param> /// <param name="threshold">The threshold to apply</param> protected void Im2Bw(Image8 im, IppiROI region) { IppHelper.IppCheckCall(ip.ippiThreshold_LTVal_8u_C1IR(im[region.TopLeft], im.Stride, region.Size, (byte)(_threshold + 1), 0)); IppHelper.IppCheckCall(ip.ippiThreshold_GTVal_8u_C1IR(im[region.TopLeft], im.Stride, region.Size, _threshold, 255)); }
/// <summary> /// Extracts for each well the most likely fish-blob or null if no suitable candidate was found /// </summary> /// <returns>All fish blobs found in the image</returns> private BlobWithMoments[] ExtractAll() { int nMarkers = 0; //we have fixed bounding boxes for each fish that are square and 1.5 times the typical fish-length //with the fishes centroid centered in the box int bbOffset = (int)(_typicalFishLength * 0.75); int bbSize = (int)(_typicalFishLength * 1.5); //Copy foreground to marker and label connected components //IppHelper.IppCheckCall(ip.ippiCopy_8u_C1R(_foreground.Image, _foreground.Stride, _labelMarkers.Image, _labelMarkers.Stride, _foreground.Size)); IppHelper.IppCheckCall(cv.ippiLabelMarkers_8u_C1IR(_foreground.Image, _foreground.Stride, _foreground.Size, 1, 254, IppiNorm.ippiNormInf, &nMarkers, _markerBuffer)); if (nMarkers > 254) { nMarkers = 254; } //fish are identified by looping over all wells and computing the histogram of pixel values for each well. This will effectively tell us //which marker is the most abundant in the given well => this would be the fish by our general detection logic //The maximum value that ippiLabelMarkers has used is equal to nMarkers. Therefore, when we compute our histogram, we supply //(nMarkers+2) as the nLevels parameter - this will give us (nMarkers+1) bins containing the counts from 0->nMarkers with 0 being our background //loop over wells for (int i = 0; i < _wellnumber; i++) { IppiROI well = _wells[i]; //get well-specific maxvalue //byte maxVal = 0; //IppHelper.IppCheckCall(ip.ippiMax_8u_C1R(_labelMarkers[well.TopLeft], _labelMarkers.Stride, well.Size, &maxVal)); //compute histogram in this well - from 0 until maxval IppHelper.IppCheckCall(ip.ippiHistogramRange_8u_C1R(_foreground[well.TopLeft], _foreground.Stride, well.Size, _hist, _histogramLevels, nMarkers + 2)); //_hist now contains in position i the abundance of marker i => by looping over it from 1->nMarkers we can find the largest blob. If this blob is //larger than our minimum size, we compute the moments and initialize a BlobWithMoments structure for it int maxCount = 0; int maxIndex = -1; for (int j = 1; j <= nMarkers; j++) { if (_hist[j] > maxCount && _hist[j] > _minArea && _hist[j] <= _maxArea) { maxCount = _hist[j]; maxIndex = j; } } if (maxIndex == -1)//no suitable fish found { _allFish[i] = null; } else { //compare and compute moments //label all pixels with the current marker as 255 and others as 0 IppHelper.IppCheckCall(ip.ippiCompareC_8u_C1R(_foreground[well.TopLeft], _foreground.Stride, (byte)maxIndex, _wellCompare.Image, _wellCompare.Stride, well.Size, IppCmpOp.ippCmpEq)); //calculate image moments IppHelper.IppCheckCall(ip.ippiMoments64s_8u_C1R(_wellCompare.Image, _wellCompare.Stride, well.Size, _momentState)); //retrieve moments long m00 = 0; long m10 = 0; long m01 = 0; long m20 = 0; long m02 = 0; long m11 = 0; long m30 = 0; long m03 = 0; long m21 = 0; long m12 = 0; ip.ippiGetSpatialMoment_64s(_momentState, 0, 0, 0, well.TopLeft, &m00, 0); m00 /= 255; ip.ippiGetSpatialMoment_64s(_momentState, 1, 0, 0, well.TopLeft, &m10, 0); m10 /= 255; ip.ippiGetSpatialMoment_64s(_momentState, 0, 1, 0, well.TopLeft, &m01, 0); m01 /= 255; ip.ippiGetSpatialMoment_64s(_momentState, 2, 0, 0, well.TopLeft, &m20, 0); m20 /= 255; ip.ippiGetSpatialMoment_64s(_momentState, 0, 2, 0, well.TopLeft, &m02, 0); m02 /= 255; ip.ippiGetSpatialMoment_64s(_momentState, 1, 1, 0, well.TopLeft, &m11, 0); m11 /= 255; ip.ippiGetSpatialMoment_64s(_momentState, 3, 0, 0, well.TopLeft, &m30, 0); m30 /= 255; ip.ippiGetSpatialMoment_64s(_momentState, 0, 3, 0, well.TopLeft, &m03, 0); m03 /= 255; ip.ippiGetSpatialMoment_64s(_momentState, 2, 1, 0, well.TopLeft, &m21, 0); m21 /= 255; ip.ippiGetSpatialMoment_64s(_momentState, 1, 2, 0, well.TopLeft, &m12, 0); m12 /= 255; _allFish[i] = new BlobWithMoments(m00, m10, m01, m20, m11, m02, m30, m03, m21, m12); //assign bounding box IppiRect bBox = new IppiRect(_allFish[i].Centroid.x - bbOffset, _allFish[i].Centroid.y - bbOffset, bbSize, bbSize); if (bBox.x < well.X) { bBox.x = well.X; } if (bBox.y < well.Y) { bBox.y = well.Y; } if (bBox.x + bBox.width > well.X + well.Width) { bBox.width = well.X + well.Width - bBox.x; } if (bBox.y + bBox.height > well.Y + well.Height) { bBox.height = well.Y + well.Height - bBox.y; } _allFish[i].BoundingBox = bBox; } }//end looping over all wells return(_allFish); }
/// <summary> /// Constructs a new multi-well tracker /// </summary> /// <param name="imageWidth">The total width of the image we want to track</param> /// <param name="imageHeight">The total height of the image we want to track</param> /// <param name="plate_index">This index is appended to the ROI file name to load file for proper plate</param> /// <param name="parallelChunks">The number of parallel chunks to track</param> public TrackerMultiWell(int imageWidth, int imageHeight, int plate_index, int parallelChunks = 2) : base(imageWidth, imageHeight) { _typicalFishLength = 30; _trackMethod = TrackMethods.PerWell;//default to per-well tracking method //Load ROIs - the following way to assess how many lines we have and hence how many //ROIs we are dealing with is ugly but what the heck its quick to think up _wellnumber = 0; var assembly = Assembly.GetExecutingAssembly(); StreamReader roiStream = null; string fileToOpen = string.Format("SleepTracker.ROI_defs_{0}.txt", plate_index); //open for prescanning var s = assembly.GetManifestResourceStream(fileToOpen); roiStream = new StreamReader(s); while (!roiStream.EndOfStream) { string line = roiStream.ReadLine(); string[] values = line.Split('\t'); if (values.Length == 4) { _wellnumber++; } } roiStream.Dispose(); //reopen to load wells s = assembly.GetManifestResourceStream(fileToOpen); roiStream = new StreamReader(s); _wells = new IppiROI[_wellnumber]; //we use the following hash-table to keep track of wells belonging //to each row. This will give us the number of rows and their boundaries //for later parallel chunk boundary determination as well as which wells //should be tracked in which chunk Dictionary <int, List <IppiROI> > wellsPerRow = new Dictionary <int, List <IppiROI> >(); Dictionary <int, int> columnStarts = new Dictionary <int, int>(); for (int i = 0; i < _wellnumber; i++) { System.Diagnostics.Debug.Assert(!roiStream.EndOfStream, "Unexpectedly reached end of ROI file"); string line = roiStream.ReadLine(); string[] values = line.Split('\t'); System.Diagnostics.Debug.Assert(values.Length == 4, "Found line in ROI file that does not contain 4 tab-separated strings"); int[] numValues = new int[4]; for (int j = 0; j < 4; j++) { numValues[j] = int.Parse(values[j]); } _wells[i] = new IppiROI(numValues[1], numValues[0], numValues[2], numValues[3]); if (wellsPerRow.ContainsKey(_wells[i].Y)) { wellsPerRow[_wells[i].Y].Add(_wells[i]); } else { //create a new list for this row and append our first well wellsPerRow[_wells[i].Y] = new List <IppiROI>(); wellsPerRow[_wells[i].Y].Add(_wells[i]); } if (columnStarts.ContainsKey(_wells[i].X)) { columnStarts[_wells[i].X]++; } else { columnStarts[_wells[i].X] = 1; } } roiStream.Dispose(); //can't have more parallel regions than we have rows of wells if (parallelChunks > wellsPerRow.Count) { parallelChunks = wellsPerRow.Count; } _allFish = new BlobWithMoments[_wellnumber]; //initialize our histogram bin boundaries (=histogram levels) //the following assignment will allow us to study marker values from 0 to 254 //since: h[k] = countof(pLevels[k] <= pixels(x,y) < pLevels[k+1]) _histogramLevels = (int *)Marshal.AllocHGlobal(sizeof(int) * 256); for (int i = 0; i < 256; i++) { _histogramLevels[i] = i; } _hist = (int *)Marshal.AllocHGlobal(sizeof(int) * 255); //assume all wells have the same size _wellCompare = new Image8(_wells[1].Size.width, _wells[1].Size.height); _parallelChunks = parallelChunks; //Initialize result array for parallel tracking _parallelTrackResults = new BlobWithMoments[_wellnumber]; //Set up image regions for parallel tracking _parallelImageRegions = new IppiROI[_parallelChunks]; //populate image regions and parallel buffers if _parallelChunks is larger 1 if (_parallelChunks > 1) { _parallelMarkerBuffers = new byte *[_parallelChunks]; _parallelMomentStates = new IppiMomentState_64s *[_parallelChunks]; //determine the number of rows in each chunk - integer division and last chunk get's the remainder tucked on int nPerChunk = wellsPerRow.Count / _parallelChunks; int nLastChunk = wellsPerRow.Count - (_parallelChunks - 1) * nPerChunk; //obtain all our row-starting coordinates and sort ascending var rowCoordinates = wellsPerRow.Keys.ToArray(); Array.Sort(rowCoordinates); //do the same for column starting coordinates var colCoordinates = columnStarts.Keys.ToArray(); Array.Sort(colCoordinates); //Inititalize our parallel-well list array _parallelChunkWells = new List <IppiROI> [_parallelChunks]; for (int i = 0; i < _parallelChunks; i++) { //for each chunk initialize it's well-list _parallelChunkWells[i] = new List <IppiROI>(); int startRowInChunk = i * nPerChunk; int endRowInChunk; //are we dealing with the last chunk - this one potentially has a different number of rows! if (i == _parallelChunks - 1) { endRowInChunk = startRowInChunk + nLastChunk - 1; } else { endRowInChunk = startRowInChunk + nPerChunk - 1; } //add all wells of this chunk to the list by looping over rows //finding their start coordinate and using that to index into //our dictionary. Then loop over the list in the dictionary for (int j = startRowInChunk; j <= endRowInChunk; j++) { foreach (IppiROI wr in wellsPerRow[rowCoordinates[j]]) { _parallelChunkWells[i].Add(wr); } } //determine top-left corner as well as width and height of this chunk int y_top = wellsPerRow[rowCoordinates[0]][0].Y; int y_bottom = wellsPerRow[rowCoordinates[endRowInChunk]][0].Y + wellsPerRow[rowCoordinates[endRowInChunk]][0].Height - 1; int height = y_bottom - y_top + 1; System.Diagnostics.Debug.Assert(height > 1); int x_left = colCoordinates[0]; int x_right = colCoordinates[colCoordinates.Length - 1] + wellsPerRow[rowCoordinates[0]][0].Width - 1; int width = x_right - x_left + 1; System.Diagnostics.Debug.Assert(width > 1); _parallelImageRegions[i] = new IppiROI(x_left, y_top, width, height); //Initialize marker buffer for this chunk int bufferSize = 0; IppHelper.IppCheckCall(cv.ippiLabelMarkersGetBufferSize_8u_C1R(_parallelImageRegions[i].Size, &bufferSize)); _parallelMarkerBuffers[i] = (byte *)Marshal.AllocHGlobal(bufferSize); //initialize moment state for this chunk fixed(IppiMomentState_64s **ppState = &_parallelMomentStates[i]) { //let ipp decide whether to give accurate or fast results IppHelper.IppCheckCall(ip.ippiMomentInitAlloc_64s(ppState, IppHintAlgorithm.ippAlgHintNone)); } } //determine each chunks start index in the fish output array based on the number of wells //in lower chunks _parallelCumWellCount = new int[_parallelChunks]; for (int i = 1; i < _parallelChunks; i++) { _parallelCumWellCount[i] = _parallelCumWellCount[i - 1] + _parallelChunkWells[i - 1].Count; } } }
/// <summary> /// Extracts a fish (candidate) from an image by performing background subtraction, noise filtering, thresholding and closing to obtain a foreground /// followed by marker extraction. /// </summary> /// <param name="im">The image to extract the fish from</param> /// <param name="region">The ROI to search</param> /// <returns>The most likely fish blob or null if no suitable candidate was found</returns> BlobWithMoments ExtractFish(Image8 im, IppiROI region) { int nMarkers = 0; //Perform background subtraction - CASH BACKGROUND IMAGE POINTER - otherwise we actually do the whole costly //32f conversion twice - once for accessing the actual image, and once for accessing the stride... var bg = _bgModel.Background; IppHelper.IppCheckCall(cv.ippiAbsDiff_8u_C1R(im[region.TopLeft], im.Stride, bg[region.TopLeft], bg.Stride, _calc[region.TopLeft], _calc.Stride, region.Size)); //remove noise via median filtering _mFiltSize.width = region.Width - 2; _mFiltSize.height = region.Height - 2; IppHelper.IppCheckCall(ip.ippiFilterMedianWeightedCenter3x3_8u_C1R(_calc[region.X + 1, region.Y + 1], _calc.Stride, _bgSubtracted[region.X + 1, region.Y + 1], _bgSubtracted.Stride, _mFiltSize, 1)); //Threshold and close Im2Bw(_bgSubtracted, _foreground, region); //Do as two step to get information back into _foreground _strel3x3.Dilate(_foreground, _calc, region); _strel3x3.Erode(_calc, _foreground, region); //Label connected components IppHelper.IppCheckCall(cv.ippiLabelMarkers_8u_C1IR(_foreground[region.TopLeft], _foreground.Stride, region.Size, 1, 254, IppiNorm.ippiNormInf, &nMarkers, _markerBuffer)); //loop over returned markers and use ipp to extract blobs if (nMarkers > 0) { if (nMarkers > 254) { nMarkers = 254; } //create or update our intermediate blob storage to store the required number of marker representations if (_blobsDetected == null || _blobsDetected.Length < nMarkers) { _blobsDetected = new BlobWithMoments[nMarkers]; } for (int i = 1; i <= nMarkers; i++) { //label all pixels with the current marker as 255 and others as 0 IppHelper.IppCheckCall(ip.ippiCompareC_8u_C1R(_foreground[region.TopLeft], _foreground.Stride, (byte)i, _calc[region.TopLeft], _calc.Stride, region.Size, IppCmpOp.ippCmpEq)); //calculate image moments IppHelper.IppCheckCall(ip.ippiMoments64f_8u_C1R(_calc[region.TopLeft], _calc.Stride, region.Size, _momentState)); //retrieve moments double m00 = 0; double m10 = 0; double m01 = 0; double m20 = 0; double m02 = 0; double m11 = 0; double m30 = 0; double m03 = 0; double m21 = 0; double m12 = 0; ip.ippiGetSpatialMoment_64f(_momentState, 0, 0, 0, region.TopLeft, &m00); //since our input image is not 0s and 1s but 0s and 255s we have to divide by 255 in order to re-normalize our moments //System.Diagnostics.Debug.Assert(m00 % 255 == 0, "M00 was not a multiple of 255"); m00 /= 255; //only retrieve other moments if this is a "fish candidate" if (m00 >= MinArea) { ip.ippiGetSpatialMoment_64f(_momentState, 1, 0, 0, region.TopLeft, &m10); m10 /= 255; ip.ippiGetSpatialMoment_64f(_momentState, 0, 1, 0, region.TopLeft, &m01); m01 /= 255; ip.ippiGetSpatialMoment_64f(_momentState, 2, 0, 0, region.TopLeft, &m20); m20 /= 255; ip.ippiGetSpatialMoment_64f(_momentState, 0, 2, 0, region.TopLeft, &m02); m02 /= 255; ip.ippiGetSpatialMoment_64f(_momentState, 1, 1, 0, region.TopLeft, &m11); m11 /= 255; ip.ippiGetSpatialMoment_64f(_momentState, 3, 0, 0, region.TopLeft, &m30); m30 /= 255; ip.ippiGetSpatialMoment_64f(_momentState, 0, 3, 0, region.TopLeft, &m03); m03 /= 255; ip.ippiGetSpatialMoment_64f(_momentState, 2, 1, 0, region.TopLeft, &m21); m21 /= 255; ip.ippiGetSpatialMoment_64f(_momentState, 1, 2, 0, region.TopLeft, &m12); m12 /= 255; if (_blobsDetected[i - 1] == null) { _blobsDetected[i - 1] = new BlobWithMoments((long)m00, (long)m10, (long)m01, (long)m20, (long)m11, (long)m02, (long)m30, (long)m03, (long)m21, (long)m12); } else { _blobsDetected[i - 1].UpdateBlob((long)m00, (long)m10, (long)m01, (long)m20, (long)m11, (long)m02, (long)m30, (long)m03, (long)m21, (long)m12); } //Determine bounding box of the blob. The following seems kinda retarded as Ipp must already //have obtained that information before so maybe there is some way to actually retrieve it?? //Do linescans using ipp's sum function starting from the blobs centroid until we hit a line //the sum of which is 0 int xStart, xEnd, yStart, yEnd; double sum = 1; IppiPoint centroid = _blobsDetected[i - 1].Centroid; xStart = centroid.x - 1; xEnd = centroid.x + 1; yStart = centroid.y - 1; yEnd = centroid.y + 1; //in the following loops we PRE-increment, whence we stop the loop if we are at one coordinate short of the ends //find xStart _bboxScan.width = 1; _bboxScan.height = region.Height; while (sum > 0 && xStart > (region.X + 4)) { xStart -= 5; IppHelper.IppCheckCall(ip.ippiSum_8u_C1R(_calc[xStart, region.Y], _calc.Stride, _bboxScan, &sum)); } xStart += 1;//we have a sum of 0, so go back one line towards the centroid //find xEnd sum = 1; while (sum > 0 && xEnd < region.X + region.Width - 5) { xEnd += 5; IppHelper.IppCheckCall(ip.ippiSum_8u_C1R(_calc[xEnd, region.Y], _calc.Stride, _bboxScan, &sum)); } xEnd -= 1;//we have sum of 0, so go back one line towards the centroid //find yStart - we can limit our x-search-space as we already have those boundaries _bboxScan.width = xEnd - xStart + 1; _bboxScan.height = 1; sum = 1; while (sum > 0 && yStart > (region.Y + 4)) { yStart -= 5; IppHelper.IppCheckCall(ip.ippiSum_8u_C1R(_calc[xStart, yStart], _calc.Stride, _bboxScan, &sum)); } yStart += 1; //find yEnd - again limit summation to x-search-space sum = 1; while (sum > 0 && yEnd < region.Y + region.Height - 5) { yEnd += 5; IppHelper.IppCheckCall(ip.ippiSum_8u_C1R(_calc[xStart, yEnd], _calc.Stride, _bboxScan, &sum)); } yEnd -= 1; _blobsDetected[i - 1].UpdateBoundingBox(xStart, yStart, xEnd - xStart + 1, yEnd - yStart + 1); } else { if (_blobsDetected[i - 1] == null) { _blobsDetected[i - 1] = new BlobWithMoments(); } else { _blobsDetected[i - 1].ResetBlob(); } } } } else { return(null); } //decide which of the detected objects is the fish //usually we pick the larger blob - however to avoid //tracking reflections on the wall, if the largest blob //and second largest blob are of comparable size //we pick the one which is closer to the center (as reflections //are always more eccentric) long maxArea = 0; long secondMaxArea = 0; int maxIndex = -1; int secondMaxIndex = -1; for (int i = 0; i < nMarkers; i++) { if (_blobsDetected[i] == null) { break; } //Note down the largest and second-largest blob - but only if those blobs aren't larger than the maxArea and if they eccentricity is at least MinEccentricity //this comparison allows that if we find two exactly same-sized blobs to consider both but to not consider any further blobs of this size (which we hopefully never have anyways) //Eccentricity and MaxAllowedArea checks removed at this point as they were mainly concieved to not track the laser. if (_blobsDetected[i].Area >= maxArea && _blobsDetected[i].Area > secondMaxArea /*&& blobsDetected[i].Area<=MaxAllowedArea && blobsDetected[i].Eccentricity>=MinEccentricity*/) { secondMaxArea = maxArea; maxArea = _blobsDetected[i].Area; secondMaxIndex = maxIndex; maxIndex = i; } } if (maxArea < MinArea) { return(null); } else { //if our second-largest blob is at least two-thirds the size //of the largest blob we also consider distance and swap accordingly if ((float)secondMaxArea * 1.5 >= (float)maxArea) { double distMax, distSecondMax; distMax = Distance.Euclidian(_blobsDetected[maxIndex].Centroid, DishCenter); distSecondMax = Distance.Euclidian(_blobsDetected[secondMaxIndex].Centroid, DishCenter); if (distMax > distSecondMax) { maxIndex = secondMaxIndex; } } return(_blobsDetected[maxIndex]); } }
/// <summary> /// Implements a "greater than" threshold like MATLABS /// im2bw function /// </summary> /// <param name="imIn">The image to threshold</param> /// <param name="imThresh">The image after thresholding</param> /// <param name="region">The ROI in which to perform the operation</param> /// <param name="threshold">The threshold to apply</param> void Im2Bw(Image8 imIn, Image8 imThresh, IppiROI region) { IppHelper.IppCheckCall(ip.ippiCompareC_8u_C1R(imIn[region.TopLeft], imIn.Stride, _threshold, imThresh[region.TopLeft], imThresh.Stride, region.Size, IppCmpOp.ippCmpGreater)); }
/// <summary> /// Uses tail start and end positions as well /// as the image size to define the track region sizes /// </summary> private void DefineTrackRegions() { lock (_regionLock) { int startx, starty, width, height; //determine if tail is horizontal or vertical if (TailIsVertical()) { starty = TailStart.y < TailEnd.y ? TailStart.y : TailEnd.y; height = Math.Abs(TailEnd.y - TailStart.y); startx = (int)((TailStart.x + TailEnd.x) / 2 - height);//ROI is centered around the tail width = 2 * height; } else { startx = TailStart.x < TailEnd.x ? TailStart.x : TailEnd.x; width = Math.Abs(TailEnd.x - TailStart.x); starty = (int)((TailStart.y + TailEnd.y) / 2 - width); height = 2 * width; } //trim to fit into image dimensions if (startx < 0) { startx = 0; } if (starty < 0) { starty = 0; } if (startx + width > _imageSize.width) { width = _imageSize.width - startx + 1; } if (starty + height > _imageSize.height) { height = _imageSize.height - starty + 1; } //compute and trim outer coordinates - morphological operations need to leave //border pixels and don't compute anything useful within the border for those //border pixels - therefore we leave a border twice the size of our structuring //element int outerx = startx - 2 * _strel.Anchor.x; int outery = starty - 2 * _strel.Anchor.y; int outerw = width + 2 * _strel.Mask.Width; int outerh = height + 2 * _strel.Mask.Height; if (outerx < 0) { outerx = 0; } if (outery < 0) { outery = 0; } if (outerx + outerw > _imageSize.width) { outerw = _imageSize.width - outerx + 1; } if (outery + outerh > _imageSize.height) { outerh = _imageSize.height - outery + 1; } //create regions _trackRegionInner = new IppiROI(startx, starty, width, height); _trackRegionOuter = new IppiROI(outerx, outery, outerw, outerh); } _bgValid = false; }