Explore Public Snippets

/// <summary>
///   Creates a new Hann Window.
/// </summary>
/// 
public static RaisedCosineWindow Hann(double length, int sampleRate)
{
    return new RaisedCosineWindow(0.5, length, sampleRate);
}

/// <summary>
/// Load bitmap from file.
/// </summary>
/// 
/// <param name="fileName">File name to load bitmap from.</param>
/// 
/// <returns>Returns loaded bitmap.</returns>
/// 
/// <remarks><para>The method is provided as an alternative of <see cref="System.Drawing.Image.FromFile(string)"/>
/// method to solve the issues of locked file. The standard .NET's method locks the source file until
/// image's object is disposed, so the file can not be deleted or overwritten. This method workarounds the issue and
/// does not lock the source file.</para>
/// 
/// <para>Sample usage:</para>
/// <code>
/// Bitmap image = Accord.Imaging.Image.FromFile( "test.jpg" );
/// </code>
/// </remarks>
/// 
public static System.Drawing.Bitmap FromFile(string fileName)
{
    Bitmap loadedImage = null;
    FileStream stream = null;

    try
    {
        // read image to temporary memory stream
        stream = File.OpenRead(fileName);
        MemoryStream memoryStream = new MemoryStream();

        byte[] buffer = new byte[10000];
        while (true)
        {
            int read = stream.Read(buffer, 0, 10000);

            if (read == 0)
                break;

            memoryStream.Write(buffer, 0, read);
        }

        loadedImage = (Bitmap)Bitmap.FromStream(memoryStream);
    }
    finally
    {
        if (stream != null)
        {
            stream.Close();
            stream.Dispose();
        }
    }

    return loadedImage;
}

/// <summary>
///   Copies a collection by calling the ICloneable.Clone method for each element inside it.
/// </summary>
/// 
/// <typeparam name="T"></typeparam>
/// <param name="list">The collection to be cloned.</param>
/// 
/// <returns>A copy of the collection where each element has also been copied.</returns>
/// 
public static T DeepClone<T>(this T list)
    where T : IList<ICloneable>, ICloneable
{
    T clone = (T)list.Clone();
    for (int i = 0; i < clone.Count; i++)
        clone[i] = (ICloneable)list[i].Clone();
    return clone;
}

/// <summary>
///   Determines whether an array is an multidimensional array.
/// </summary>
/// 
public static bool IsMatrix(this Array array)
{
    return array.Rank > 1;
}

/// <summary>
/// Convert from RGB to YCbCr color space (Rec 601-1 specification). 
/// </summary>
/// 
/// <param name="rgb">Source color in <b>RGB</b> color space.</param>
/// <param name="ycbcr">Destination color in <b>YCbCr</b> color space.</param>
/// 
public static void FromRGB(RGB rgb, YCbCr ycbcr)
{
    float r = (float)rgb.Red / 255;
    float g = (float)rgb.Green / 255;
    float b = (float)rgb.Blue / 255;

    ycbcr.Y = (float)(0.2989 * r + 0.5866 * g + 0.1145 * b);
    ycbcr.Cb = (float)(-0.1687 * r - 0.3313 * g + 0.5000 * b);
    ycbcr.Cr = (float)(0.5000 * r - 0.4184 * g - 0.0816 * b);
}

/// <summary>
        ///   Creates a rows-by-cols matrix random data drawn from a given distribution.
        /// </summary>
        /// 
        [Obsolete("Please use INumberGenerator<T> instead.")]
#pragma warning disable 0618
        public static double[,] Random(int rows, int cols, IRandomNumberGenerator generator)
        {
            return Random<double>(rows, cols, new RandomNumberGeneratorAdapter(generator));
        }

/// <summary>
///   Transforms a vector into a matrix of given dimensions.
/// </summary>
/// 
public static T[][] Reshape<T>(this T[] array, int rows, int cols, T[][] result, MatrixOrder order = MatrixOrder.Default)
{
    if (order == MatrixOrder.CRowMajor)
    {
        int k = 0;
        for (int i = 0; i < rows; i++)
            for (int j = 0; j < cols; j++)
                result[i][j] = array[k++];
    }
    else
    {
        int k = 0;
        for (int j = 0; j < cols; j++)
            for (int i = 0; i < rows; i++)
                result[i][j] = array[k++];
    }

    return result;
}

/// <summary>
        ///   Returns a matrix with a vector of values on its diagonal.
        /// </summary>
        /// 
#if NET45
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
        public static T[][] Diagonal<T>(int rows, int cols, T[] values, T[][] result)
        {
            int size = Math.Min(rows, Math.Min(cols, values.Length));
            for (int i = 0; i < size; i++)
                result[i][i] = values[i];
            return result;
        }

/// <summary>
///   Computes the Cartesian product of two sets.
/// </summary>
/// 
[Obsolete("Please use Cartesian instead.")]
public static T[][] CartesianProduct<T>(this T[] sequence1, T[] sequence2)
{
    return Cartesian(new T[][] { sequence1, sequence2 });
}

/// <summary>
///   Converts a signed 16-bit integer sample
///   into a 32-bit signed integer sample.
/// </summary>
/// 
/// <param name="from">The original sample.</param>
/// <param name="to">The resulting sample.</param>
/// 
public static void Convert(Int16 from, out Int32 to)
{
    to = (byte)(((from) >> 8) + 128);
}