Professional Documents
Culture Documents
5 release notes
----------------------------------------
17.07.2013.
!!!IMPORTANT!!!
* AForge
- Added SquaredDistanceTo() method to Point/IntPoint/DoublePoint, which returns
square of Euclidean distance.
* AForge.Math
- Fixed GrahamConvexHull so it handles correctly lists with 1 point only. Unit
test is added.
* AForge.Imaging
- Set minimum allowed value for ColorFactor, ColorPower, SpatialFactor and
SpatialPower properties of
BilateralSmoothing to 1.
- Fixed OtsuThreshold bug, which was leading to wrong threshold calculation for
images with highest intensity
maller than 255.
- Fixed blobs' color standard deviation calculation for 8bpp grayscale images.
- Fixed Sobel edge detector so it does not write beyond image buffer when doing
intensity scaling step.
- Added 32 bpp RGB pixel format to the list of supported formats for motion
processing classes.
- Minor fix for HSL to RGB conversion to make sure Alpha byte is always set to
255.
- Allow creating instance of replace channel filters without specifying image for
the channel to replace.
* AForge.Neuro
- Added implementation of ICloneable interface to activation functions.
* AForge.Video
- Increased buffer size for JPEG/MJEPG stream reader classes.
* AForge.Video.DirechShow
- Updated FilterInfo class, so Name and MonikerString are no longer read only
fields but read only properties.
- Fixed setting crossbar's video input for devices which may have multiple inputs
of the same type (like capture boards).
- Updating version of FFMPEG library being used to 2012-01-27 - the last version
before API got changed.
* AForge.Controls
- Merged the fix which adds property allowing to keep aspect ratio in
VideoSourcePlayer.
* AForge.Robotics.TeRK
- The Qwerk class is marked as deprecated.
* AForge.Robotics.Lego
- The RCXBrick class is marked as deprecated.
* AForge.Video.DirechShow
- Resetting flag which requires update of crossbar input right after the input
type was set. There was a bug
in the code which was resulting setting crossbar input type again and again
causing flickering.
* AForge.Math
- Fixed Complex.Phase property, so it provides proper value for cases when real
part is less than zero.
* AForge.Imaging
- Blob'c constructor is made public, so could be reused by using inheritance.
* AForge.Neuro
- Replaced Neuron's static random numbers generator with its thread safe version.
* AForge.Video.DirechShow
- VideoCaptureDevice is updated to never provide null for VideoCapabilities
property. If device does not support video
capabilities or it failed providing them, then the property will return 0
length array, but not null.
* AForge.Video.FFMPEG
- Fixing VideoFileReader and VideoFileWriter classes so they convert file name to
UTF8 string before opening file.
* AForge.Video.Kinect
- Updating libfreenect library with newer version which is checked out from
master branch and built on February 20 2012.
- Updated Kinect cameras' stopping routines, so they don't block when device was
disconnected and user tries to stop cameras.
* AForge.Controls
- Updated Chart control so it does not check if points coordinates are in X/Y
range of the control when drawing them.
Instead of this the control sets clipping rectangle, so unwanted point/lines
are not drawn.
* General
- Updated project/solution files of the framework's sources, tool and unit tests
to VS.NET 2010 (C#/C++ express 2010).
* AForge
- Added ThreadSafeRandom class which is a wrapper for the System.Random class
providing thread safety for random numbers
generation methods.
* AForge.Imaging
- Added implementation of Run Length Smoothing Algorithm (horizontal and vertical
versions).
- Improved performance of grayscale filters so those are about ~4.5 times faster
doing conversion of 24/32 bpp color
images to 8 bpp grayscale images, which is achieved by replacing floating point
calculation with integer calculation.
- Fixed rotation filters, so those don't shift image by one pixel, which was easy
to notice when rotating by -90/90 angles.
The bug was caused by the fact that for edge pixels source position was
calculated one pixel out of image's bounds.
* AForge.Genetic
- Updated classes of AForge.Genetic namespaces to use new ThreadSafeRandom class,
so random numbers generation in those
classes becomes thread safe.
* AForge.Video
- Changing IVideoSource.BytesReceived property type from int to long, so it may
fit higher values.
* AForge.Video.FFMPEG
- Allow specifying of video stream bit rate when open video file using
VideoFileWriter, so user could trade between
video quality and file size.
* AForge.Video.DirectShow
- Fixed BytesReceived property of FileVideoSource and VideoCaptureDevice, so
those provide number of provided bytes.
* Samples
- Fixing few bugs in Blobs Explorer sample application:
+ If convex hull contain 3 point or less, then don't try finding its
quadrilateral;
+ If object's edge contains only one pixel, then need to draw it individually
instead of using Graphics.DrawLines() method.
* AForge.Imaging
- Fixing AForge.Imaging.RGB class, so by default alpha channel is initialized
with 255 (not transparent). Also updated HSL
and YCbCr converters to set alpha to 255.
- Added optimized version of Bayer filter, which is optimized for GRBG and BGGR
patterns. Compared to generic version, the
optimized version is about 10 times faster.
- Added ApplyMask image processing routine which applies mask to the specified
image - keeps original pixels' values or
sets them to 0 depending on corresponding value in the mask image/array.
- Added MaskedFiler image processing routine, which allows to apply filter only
the part of image specified by mask
(0 values of mask tell that original pixel's value must be kept; otherwise -
filtered).
- Fixed flood fill classes to avoid conversion of pointer to Int32 so they should
work fine on 64 bit systems.
* AForge.Math
- Added fix to PointsCloud.FindQuadrilateralCorners() so it does provide 2 same
corners in the case when both 3rd and 4th
potential corners are very close to the line connecting 1st and 2nd corner.
* AForge.Vision
- Fixed one of the constructors for BlobCountingObjectsProcessing so it passes
its parameter (highlighting motion detection)
further to another constructor.
* AForge.Video.DirectShow
- Moving VideoCaptureDeviceForm from Player sample application to
AForge.Video.DirectShow namespace and beautifying it a bit.
Now the form can be reused in other applications, which require selection of
local video devices.
- Updating COM interop definition for few interfaces of DirectShow (should get
more stable in some cases).
* AForge.Video.Ximea
- Added additional camera parameters/enumerations for XIMEA cameras.
* AForge.Controls
- Updating some AForge.Controls classes to use AForge.Imaging instead of internal
tools since this assembly references
AForge.Imaging.dll anyway.
- Fixing few bugs in Chart control: fixed cloning of data input data and fixed
drawing of dots series type.
* Tools
- Adding AForge.DebuggerVisualizers tool assembly, which allows visualizing
Image, BitmapData, UnmanagedBitmap
and Histogram objects during debugging.
* Samples
- Fixing Motion Detector sample to perform safe update of UI (avoid cross thread
access).
AForge.NET Framework 2.2.1 release notes
----------------------------------------
03.08.2011.
* AForge.Math
- Fixing == operator for Line and LineSegment classes, so it does not cause
exception when line is compared with null.
* General
- Adding AForge.Video.FFMPEG namespaces, which provides classes allowing to
read/write video file through
FFmpeg library API. The code is experimental so far and is going to be extend.
When extended it is supposed to
become replacement for AForge.Video.VFW namespace someday.
- Removing all use cases of lock(this) and replacing them with locking a dummy
object.
* AForge
- Adding Point structure, which contains X/Y coordinate of float type. Adding
Range structure, which is range between
min/max of float type. Changing all AForge.NET framework classes and samples to
work with Point/Range instead of
DoublePoint/DoubleRange, which are left for some applications requiring higher
precision.
* AForge.Imaging
- Added TransformToPolar image processing routine which transforms source image
to polar coordinates. Produced effect is
similar to the one available in GIMP as "Polar Coordinates" distortion filter.
The new class provides similar properties
as configuration options in GIMP.
- Added Bayer filter routine, which creates color image out of grayscale image
produced by image sensor built with
Bayer color matrix.
- CanvasMove is extended to support 16 bpp grayscale and 48/64 bpp color images.
* AForge.Imaging.Formats
- Updated ImageDecoder.DecodeFromFile() to load load standard image formats (BMP,
JPG, PNG, etc.) through memory stream
instead of using standard .NET's FromFile( string fileName ) to avoid locking
of the file.
* AForge.Math
- Adding Math.Vector3 structure which provides some operations on 3D vectors.
- Added equality and inequality operator for Line and LineSegment classes, as
well as Equals() and GetHashCode() methods.
* AForge.Video
- Minor update to AsyncVideoSource class - changing manual reset event to auto
reset.
- Added Proxy property to both JPEGStream and MJPEGStream classes, which allow
user to specify proxy server to use.
* AForge.Video.DirectShow
- Updating VideoCapabilities class to provide multiple supported FPS rates for a
particular resolution.
- When desired video size is set, perform search of complete media type structure
and set it as it is configured when enumerating
capabilities (fixes thes issue with Microsoft's LifeCam).
* AForge.Video.VFW
- Updating exception types thrown by AVIReader and AVIWriter, so they are
different for different type of exceptions.
* AForge.Robotics.Lego
- Added constructor for NXTBrick.MotorState structure, so it is "easer" to
initialize it from user's code.
- Turned NXT structures into classes and provided properties for them (many of
them are read-only since those are supposed to
be set by framework, not by user).
- Some improvements for communication with Lego NXT brick, see ticket #219
* AForge.Controls
- VideoSourcePlayer is extended to support cameras providing 16 bpp grayscale or
48/64 bpp color image.
- Merged HuePicker control from IPLab project into the AForge.NET framework. Some
polishing of the class and its documentation
was done.
- Making sure VideoSourcePlayer control gets resized if image from video source
changes its size.
- Fixing VideoSourcePlayer so it does not cause dead lock if user does access to
UI using Invoke() in NewFrame event handler
(moving NewFrame event firing out of lock block).
- Making sure that Chart control displays only data which are in the configure
x/Y range. Also updating Y range if required
when new X range is set.
* Tools
- Added check for IPPrototyper's window position stored in configuration file. If
window outside of the screen, then use its
default location. Window may get outside if the application was used on a
system with multiple screens last time and the it
is started again when one of the screens got disconnected.
* Samples
- Adding Snapshot Maker sample application, which demonstrates recently added
feature for making snapshots using DirectShow
device (USB camera).
- Improving FPS counter for "Player" and "Two Camera Test sample" applications.
!! This version has backward incompatibility with the previous version (see details
below) !!!
* AForge
- Fixing bug in IntRange.IsOverlapping() and DoubleRange.IsOverlapping(), when
these methods report
"false" (no overlapping) in the case if specified range completely covers and
wider than the range
of the instance which method is invoked.
*AForge.Math
- Added a check for greater than 0 in IsPowerOf2() function. It will return false
for everything which is <= 0.
- Introducing Line class in AForge.Math.Geometry, which is supposed to keep
lines' related methods.
- Fixes to PointsCloud.FindQuadrilateralCorners():
1) Fixing the issue of detecting flat rectangles with high aspect ratio between
adjacent sides;
2) Adding PointsCloud.QuadrilateralRelativeDistortionLimit static property, so
user could tweak distortion limit
if he understands what he does.
* AForge.Imaging
- Adding support for custom blobs' filtering routines, which implement
IBlobsFilter interface.
- Fixing Convolution image processing filter to copy alpha channel values as they
are for 32 bpp images.
- Adding FillHoles image processing routine, which allows to fill black holes in
white objects in binary images.
- Adding color dithering image processing routines, which are placed into
AForge.Imaging.ColorReduction namespace.
- Adding local thresholding routine described by Derek Bradley and Gerhard Roth
in the "Adaptive Thresholding Using
the Integral Image" paper (see BradleyLocalThresholding class).
- Adding ThresholdedDifference and ThresholdedEuclideanDifference, which
calculate threshold difference of two images
(one class uses Manhattan distance to calculate difference between pixel
values, but another class uses Euclidean distance).
- Changing bicubic kernel for resize and rotation image processing routines to
the one described on Wikipedia
(coefficient "a" is set to -0.5).
* AForge.Video
- Updating MJPEGStream video source class to remove double quotes from start/end
of boundary, which can
be added by some IP cameras.
* AForge.Video.DirectShow
- Fixed bug in disposing of DirectShow AMMediaType structure. The bug was
introduced in 2.1.4 version.
* AForge.Genetic
- Modified PermutationChromosome.CreateChildUsingCrossover() to use arrays for
fast lookup of genes'
indexes in parents' chromosomes.
* AForge.Controls
- Added check for cross-thread access to most methods/properties (those which are
not allowed to be accessed
from another thread) of VideoSourcePlayer class. Lock is still kept in some
methods/properties, which access
video frame (this must be protected anyway).
* IPPrototyper
- Adding AutoSize size mode for picture box, which is nice to have when
processing big images, which may need scrolling.
* General
- Adding some unit test based on Gallio Automation Platform. The unit tests
mostly cover new
recently added features for now. See "Unit Tests\Read Me.txt" for additional
information.
* AForge
- Added IntPoint.EuclideanNorm() and DoublePoint.EuclideanNorm() methods, which
calculate point's
distance to (0, 0) point.
* AForge.Math
- Switching GeometryTools class to be public, which contains few tool methods to
calculate angle
between two vectors and angle between two lines.
- Fixing bug of GetCenterOfGravity(), where first point was not taken into
account.
* AForge.Imaging
- Fixing an old somehow survived typo - changing "FormatTransalations" to
"FormatTranslations".
This change may affect those users, who use the property.
- QuadrilateralTransformationBilinear and
QuadrilateralTransformationNearestNeighbor are marked as deprecated
and generate warning if used. But still work.
* AForge.Video.DirectShow
- Fixing disposing of AMMediaType.
- Improving FileVideoSource, so it can play video files which have audio stream
as their first stream
(which becomes first output pin of IBaseFilter). First output pin was always
taken before and used for
connection with input pin of sample grabber. However it was failing in those
cases, when first output pin
had audio type. Now the code is changed to iterate through source's output pins
searching for one, which
can be connected with sample grabber.
* AForge.Controls
- Adding addition "request to stop" volatile boolean variable in
VideoSourcePlayer to avoid trying
handle NewFrame event when WaitForStop() is already invoked, so rare deadlock
is avoided.
* Samples
- Adding "IPPrototyper Sample" application - demonstrates usage of IPPrototype
tool.
* AForge.Math
- Adding interface for shape optimizers its 3 implementations:
1) FlatAnglesOptimizer - shape optimizer, which removes obtuse angles (close
to flat) from a shape;
2) LineStraighteningOptimizer - shape optimizer, which removes points within
close range to shapes' body;
3) ClosePointsMergingOptimizer - shape optimizer, which merges points within
close distance to each other.
- Bug fix in GrahamConvexHull - don't process points with same coordinates as the
first point.
* AForge.Imaging
- Fixing SusanCornersDetector - don't dispose internal grey image in the case if
greyscale image was given as input.
- Increasing size limits for convolution's kernel size and structuring element of
morphological operators. The limit is set to 99. The benefit of such big
kernels
is not clear, but if users want it and ready to wait until such lengthy image
processing
is done, then why not to give it to them.
* AForge.Video
- Putting check of IsRunning property into Start() method of all video sources,
so
it checks if video source is really running or not. Checking thread variable
for null
was not a good check if user calls SignalToStop() without further
WaitForStop().
* AForge.Video.DirectShow
- Merging the code contributed by Jeremy Noring, which allows to disable
reference clock
of a DirectShow graph allowing to process video files as fast as possible.
* AForge.Genetic
- Fixing Population.FindBestChromosome() method to make sure that a chromosome
will be selected
even if all chromosome have fitness value equal to 0.
* AForge.Robotics.Surveyor
- Added SVS.ServosBank.Bank0, so users could control servos connected to TMR2-1
and TMR3-1 of
SVS board (in the case of some custom set-up).
* Samples
- Added sample application to demonstrate usage of SimpleShapeChecker class.
* AForge
- Adding addition, subtraction, multiplication and division operators between
IntPoint/DoublePoint and scalar values.
* AForge.Imaging
- Fixed a rounding bug in Hough Line Transformation, causing unnecessary doubling
of the Hough transformation
values near zero radius.
- Added ImageWarp image processing filter, which sets pixels in destination image
to values from source image taken
with specified offset.
- Added two more properties into Blob class, which are calculated by
BlobCounterBase automatically - mean and standard
deviation of blob's color.
* AForge.Math
- Add PointsCloud.GetBoundingRectangle() method to search for minimum/maximum
X/Y coordinates in the specified
list of points.
- Update constructor of GaussianGenerator to pass specified seed to
StandardGenerator, which was previously ignored.
* AForge.Fuzzy
- "NOT" operator is implemented for fuzzy rules.
* AForge.Controls
- Removing generation of exception in the case if user tries to change video
source for VideoSourcePlayer control
without stopping currently played. User may want to control video starting and
stopping on his own, so control
should not add any restrictions regarding this.
* AForge.Video
- Fixing MJPEGStream to skip clients' notification, if the video source was
requested to stop.
- Adding support for AirLink IP cameras, which are not very accurate with HTTP
standard (fix contributed by Ivan Farkas).
* AForge.Video.DirectShow
- Fixing some memory leaks (COM objects) in AForge.Video.DirectShow.
* AForge.Robotics.Surveyor
- Fixing bug in SVS.Disconnect() method - wrong object was accessed for aborting
right camera.
- Adding check to make sure stopEvent is not null, which may happen when tread is
aborted (solves rare
NullReferenceException, which may happen on disconnecting from SRV-1).
* General
- Updating titles of all assemblies, so they look nice if they are registered on
the .NET page of "Add Reference"
dialog in VS.NET.
- Updating install script - after installation of AForge.NET Framework its
assemblies will be seen on .NET page
of "Add Reference" dialog in VS.NET
* AForge
- Fixed operator- for DoublePoint and IntPoint classes.
* AForge.Imaging
- Added Image.FromFile() method to workaround the issue of standard .NET method,
which locks file until image
object is disposed.
* AForge.Robotics.Surveyor
- Adding method to access I2C devices connected to SRV-1/SVS robots.
- Removing new line check for replies which start with '##'. The SRV-1 protocol
is real pain to work with.
* AForge.Video.DirectShow
- Replacing interop usage of olepro32.dll to oleaut32.dll for
OleCreatePropertyFrame() API call, so accessing
this API call works correctly on Windows 64-bit version.
* AForge.Controls
- Added check for max equals to zero to avoid painting histogram when there is
nothing to paint actually.
* General
- Added new AForge.Robotics.Surveyor namespace containing classes to manipulate
Surveyor's
SRV-1 Blackfin robot and SVS (Stereo Vision System) board.
* AForge
- Adding IntPoint structure as alternative to .NET's System.Drawing.Point.
DoublePoint is updated
to be similar to IntPoint.
* AForge.Imaging
- Added StereoAnaglyph image processing filter to create anaglyph images from 2
images of the
same scene taken from a bit different points.
* AForge.Math.Geometry
- Added PointsCloud tool class, which includes set of method to work with
collection of points ("clouds").
These methods include: getting furthest point from a reference point; getting
furthest point from
specified line; finding quadrilateral corners for the specified set of points.
- Added Graham scan algorithm for searching convex hull of the specfied set of
points.
* AForge.Robotics.Surveyor
- Added SRV1 class - allows to manipulate Surveyor's SRV-1 Blackfin robot.
- Added SRV1Camera class - allows to get continuous video feeds from SRV-1 and
SVS robots.
* AForge.Video
- Added possibility to configure HTTP User Agent for MJPEG requests. By default
it is set
to "Mozilla/5.0".
* AForge.Video.DirectShow
- In the case if camera's driver does not allow several copies of video source
object, we pass the request
for displaying property page to background thread, which deals with video
capture. Otherwise we create second
source object and use it as before. (fixing 106 and 113)
* Samples
- Added SVS Test sample application, which allows to get video from Surveyor's
SVS board,
show stereo anaglyphs for it and drive the robot.
- Added SRV-1 Test sample application, which allows to get robot's video and
drive it.
* AForge
- Added zero initialization of allocated unmanaged images, since
Marshal.AllocHGlobal() does not
care about it.
* AForge.Imaging
- Fixed UnmanagedImage.FromManagedImage() method - it was allocating unmanaged
image, but was not
copying managed image to it.
* AForge.Imaging.Formats
- Added registration of PPM extension as valid image in PNM format.
* AForge.Neuro
- Added ability to change activation function of neuron/layer/network.
* AForge.Robotics.Lego
- Added GetUltrasonicSensorsValue() method for NXT brick to read values of
ultrasonic distance sensor.
* AForge.Robotics.TeRK
- Added 2500 ms connection timeout to Qwerk classes. QwerkStart sample update to
handle lost connection.
* AForge.Video
- Added PlayingFinished event to IVideoSource interface. The event is fired in
the case video
stops by reaching end of video stream or by canceling by user.
* AForge.Video.DirectShow
- Added VideoCapabilities property to VideoCaptureDevice class, which can be used
to resolve supported
frame sizes and maximum frame rates.
* AForge.Vision
- MillisecondsPerBackgroundUpdate property is introduced in
SimpleBackgroundModelingDetector, which
allows to control background update on the base of time intervals, but not on
the base of frames'
counter. This allows to control background update in the way, which is not
affected by variable frame
rates. Also the method better handles those case, when video source has very
low frame rate (where
FramesPerBackgroundUpdate would not perform very well causing very long time to
update background).
* Samples
- Fixing FilterDemo application - added grayscaling before edge detectors (all
edge detectors
require grayscaling).
* AForge.Fuzzy
- New class SingletonFunction: new kind of membership function, to represent
classical numerical numbers in fuzzy domain.
- Inference System was modified to allow the user to access the fuzzy output
before defuzzyfing.
* AForge.Imaging
- All exceptions classes, which were introduced in BETA versions, are renamed to
have Exception ending.
- Added Threshold property to the Convolution filter, which allows to set value
to be added to weighted sum of pixels.
- Crop filter bug is fixed (the filter was calculating pixel size incorrectly).
* AForge.Video.DirectShow
- Video classes are updated to skip preparing new video frame, if nobody is
subscribed for NewFrame
event (decreases CPU usage if no subscribed clients).
* AForge.Vison
- The namespace was completely redesigned to introduce motion detection and
motion processing algorithms.
In the past both these algorithms were part of each motion detection class,
which was not flexible, not reusable
and not extendable.
* Samples
- Motion Detection sample application is updated to use new classes of the
redesigned AForge.Vision namespace.
Also added feature to show motion history.
* General
- Added new AForge.Fuzzy namespace containing classes for building fuzzy systems
(many thanks to Fabio Caversan, who is the main contributor to it).
* AForge
- Parallel class is added providing Parallel.For() method aimed for paralleling
computations across all cores in they system.
* AForge.Math
- Complex structure is extended with set of new methods providing wider range of
operations with complex numbers.
* AForge.Imaging
- Added new set of base classes for image processing filters. These classes are
more flexible in support of different image formats and also provide runtime
information about filters - which formats are supported by image processing
filter and which format will be generated for result image.
- Introduced support of unmanaged images - images, which are don't have relation
with Bitmap and BitmapData classes from .NET. Unmanaged images are just pixel
data
in unmanaged memory.
- Added PointedMeanFloodFill, which fills image starting from the specified point
with mean value of the filled area. Size of the area to fill depends on
specified tolerance.
- Added optimized versions of Erosion and Dilatation filters, which are aimed for
image processing with 3x3 structuring element and are optimized for certain
image formats: BinaryDilatation3x3, BinaryErosion3x3, Dilatation3x3,
Erosion3x3.
* AForge.Controls
- Added PictureBox control, which is derived from .NET's control, but supports
displaying of 16 bpp grayscale image and 48/64 color images, which are not
handled by .NET routines.
- Added ColorSlider control, which is aimed for selection of RGB color value
and ranges.
* AForge.Genetic
- Added support for migration between genetic populations. User may run several
population in deferent threads for example and perform members' migration
from time to time. See Population.Migrate() method.
* AForge.Neuro
- Added support of using network classes from multiple threads (thread safety).
See documentation to Layer.Compute() and Network.Compute() for details.
- Added Two Cameras Test sample application, which demonstrates how to open
two web cameras simultaneously. Also may serve as useful utility of testing
two cameras from the same manufacturer (some cameras do not support dual
setup, so it is nice to have something to that quickly).
* General
- Support for Lego RCX Mindstorm robotics kit is introduced. RCX test/demo
application is provided.
* AForge.Imaging
- SUSAN corners detector is implemented.
- Correlation filter is removed to avoid any confusion. The filter was doing the
same as convolution
filter, but with mirrored/flipped kernel.
* AForge.Robotics.Lego
- RCXBrick class introduced, which provide functionality to perform some
manipulations with Lego RCX
Mindstorm brick.
* AForge.Imaging
- Small tuning of HSL image statistics class - to check if pixel is black it is
required to check only
luminance component (all non-black pixels will form non-zero luminance).
* AForge.Vision
- HighPrecisionBackgroundModeling class is fixed to handle correctly the case
when noise suppression is
off and motion edges highlighting is on.
- Added more checks to handle the case when user passes motion zones array with 0
elements.
- Motion zone routines are updated to lock motion detector object (this) instead
of motionZones variable
since it may be null and lead to exception.
* AForge.Video.DirectShow
- Added functionality to display property page of video capture device, which
allows changing its
settings provided by driver (contrast, brightness, frame size, etc).
* AForge.Imaging
- Canny Edge Detector is fixed to use floating point gradients array to correct
non-maximum suppression
and location of edge points.
* AForge.Imaging
- Flat Field Correction filter is added.
* AForge.Neuro
- Save() and Load() methods are added to Network class, which allow to
serialize/deserialize neural network.
* General
- AForge.NET framework's license is updated and clarified. The license
concentrates not on commercial
vs. not-commercial software but on open vs. closed software. The framework is
provided under dual
license: GPL v2 for free and LGPL for a fee. Please, refer to License.txt
document for more
details.
* AForge.Imaging
- Otsu thresholding is added (N. Otsu, "A threshold selection method from gray-
level histograms",
IEEE Trans. Systems, Man and Cybernetics 9(1), pp. 62�66, 19790).
* AForge.Math
- Added Update() method to histogram classes, so it is possible to recalculate
statistical values after
direct changes in Values array of histogram.
* AForge.Video.DirectShow
- Fixed the issue that it was not possible to play some videos. The issue was
cause by fixing issue 22
(1.5.1 version). Removing call of graph's Render() method solves the issue with
freezing video after screen
saver, but introduces another issue when playing some video files. The Render()
method is adding not only
renderer filter, but some other filters, which may be required. To configure
this, a new property was
introduced - PreventFreezing, which allows to select what is required -
freezing preventing removing Render()
call or not preventing leaving it.
* AForge.Controls
- Histogram control is added to AForge.Controls namespace, which is originally
taken from IPLab application,
but extended with vertical histograms support.
* AForge.Imaging
- BlobCounterBase class was introduced to serve as a base for different blob
counting algorithms.
- Recursive blob counter was added. This blob counting algorithm is slower than
existing one, but due its
simplicity can be used for testing other algorithms. Improvements can be done.
- Blob counter base class is updated to support not only Bitmap and BitmapData,
but raw data in unmanaged
memory.
- Drawing class was introduced to keep different drawing routines, which can be
applied to BitmapData.
Rectangle routine is provided for now only.
* AForge.Vision
- ICountingMotionDetector interface was introduced, which describes interface for
motion detection algorithms
with objects counting support.
* AForge.Video.DirectShow
- VideoCaptureDevice and FileVideoSource classes were updated - Render() method
call of IGraphBuilder interface
was removed. The method was completing graph with additional filters required
for rendering, which were
causing video stopping in the case of screen saver or workstation locking.
Since we use Sample Grabber and
we do our own rendering, the call was not actually required.
* Samples
- Motion Detector sample was updated to demonstrate counting motion detector and
motion zones configuration.
* AForge.Math
- AForge.Math.Statistics.Mean() was fixed to use double for mean calculation
instead of int,
what was causing incorrect mean value (in the case of histogram with large
values).
* AForge.Imaging
- Simple memory manager class added for allocation/dialocation unmanaged memory,
which
could be required for image processing filters.
- New base class for partial filtering of color images was introduced
(FilterColorToColorPartial).
- New base class for partial filtering of grayscale images was introduced
(FilterGrayToGrayPartial).
- New base class for partial filtering of color and grayscale images was
introduced
(FilterAnyToAnyPartial).
- New base class for partial filtering of color and grayscale images was added
(FilterAnyToAnyUsingCopyPartial). The class allows to do partial "in-place"
filtering
for those filters, which can not do direct manipulations with source image.
- New base class for partial filtering of grayscale images was added
(FilterGrayToGrayUsingCopyPartial).
The class allows to do "in-place" filtering for those filters, which can not do
direct manipulations
with source image.
- Oil Painting filter fixed to clear intensities array correctly (issue 23).
* General
- Added new namespaces: Video.DirectShow;
* AForge.Video.DirectShow
- VideoCaptureDevice class added to access local video capture devices like USB
webcams
using DirectShow;
- FileVideoSource added to access video files using DirectShow (DirectShow
supports more
video codecs than Video for Windows so this class allows to play wider range of
video
files).
* AForge.Imaging
- Fixed an issue with out of range coordinates checking in Hough Circle
Transformation.
* AForge.Imaging
- Iterative threshold filter is added;
- Canvas crop and canvas move filters added;
- Canvas Fill filter added;
- SISThreshold updated to use absolute difference for X and Y directions;
- Added Hough line transformation to detect lines;
- Added Hough circle transformation to detect circles;
* AForge.Vision
- Added property to restore objects edges after noise suppression ( Background
modeling high
precision motion detector);
* AForge.Video
- MJPEG video source implementation updated to search for JPEG magic number
instead of searching
for newline delimiter;
* AForge.Video.VFW
- Added thread safety for AVIReader and AVIWriter;
* AForge.MachineLearning
- Roulette Wheel exploration policy added;
- Boltzmann exploration rate fixed to handle correctly infinite probabilities;
- Action estimates randomization added for QLearning and Sarsa;
* Samples
- Add sample to demonstrate Hough line and circle transformation.
* General
- Added new namespaces: MachineLearning, Vision, Video, Video.VFW;
- Password protection removed from signing keys;
* AForge.Imaging
- Binarization filters updated so they can be applied to grayscale images only;
- Replace channel filter updated so it can be created without specifying channel
image;
- Bug fixed in FilterAnyToAny - image was not locked correctly and pixel format
was not checked correctly for in-place filtering;
- Bug fixed in Replace Channel filter - pixel format of channel image was not
checked correctly;
- Added method to clone image from Bitmap Data;
- Top-Hat and Bottom-Hat filters added;
- Noise generation filters added - additive noise and salt&pepper noise;
* AForge.Vision
- Two frames difference motion detector added;
- Background modeling high precision motion detector added;
- Background modeling low precision motion detector added;
* AForge.Video
- IVideoSource interface added;
- JPEG video source added;
- MJPEG stream video source added;
* AForge.Video.VFW
- AVI reader class added;
- AVI writer class added;
- AVI file video source added;
* AForge.MachineLearning
- QLearning and Sarsa learning algorithms added;
- Epsilon greedy, Boltzmann and Tabu Search exploration policies added;
* Samples
- Animat sample added - demonstrates MachineLearning namespace;
- MotionDetector sample added - demonstrates Vision and Video namespaces;
* General
- Setup project added to provide installer application;
- AForge.NET libraries got strong name;
- Sample applications update to use volatile for need-to-stop flag
* AForge.Math
- Random numbers generators added (Uniform, Standard, Gaussian, Exponential);
- 2D Affine transformation added;
* AForge.Imaging
- Texture class added to handle texture related work;
- BlobCounter class updated to have constructor. GetObjectRectangles() does not
require parameter any more;
- Bug fixed in ComplexImage - image mode was not cloned;
- Color remapping filter was added
* AForge.Genetic
- Double array chromosome added
* General
- The framework was converted to .NET 2.0;
- Sandcastle is used for help files generation instead of NDoc;
* AForge
- Issue fixed with IsInside() method of IntRange and DoubleRange
* AForge.Math
- Complex number structure;
- Fourier transformation;
- Gaussian function;
- Perlin noise function;
- Statistics class;
- Histogram classes;
* AForge.Imaging
- Blob counter and Connected Components Labeling;
- Conservative Smoothing filter;
- Jitter filter;
- Oil Painting filter;
- Pixellatet filter;
- Gaussian Blur filter;
- SharpenEx (based on Gaussian function) filter;
- Canny Edge Detector filter;
- Adaptive Smooth filter;
- Simple Skeletonization filter;
- Texture generators added (Clouds, Marble, Wood, Labyrinth, Textile);
- Texturer, Textured Filter, Textured Merge filters;
- Resize filters (Nearest Neighbor, Bilinear, Bicubic);
- Rotate filters (Nearest Neighbor, Bilinear, Bicubic);
- Complex image (frequency filtering);
- Image statistics classes (RGB, HSL, YCbCr);
* Samples
- Textures demo application;