public static void TestDCT_Quantize()
{
Dct dct = new Dct();
print("DCT Test");
var d = dct.Go(testdata);
print("Quantized dct");
Quantizer.QuantizeLuminance(ref d);
d.PrintArray();
print("Quantized Inverse");
Quantizer.InverseQuantizeLuminance(ref d);
print("Dct Inverse");
dct.GoBack(d).PrintArray();
}
public void Setup()
{
originalBitmap = new Bitmap(resourcesPath + "c_corgi.jpg");
watermarkBitmap = new Bitmap(resourcesPath + "w_tekst_dolny.png");
expectedDctBitmap = new Bitmap(myResourcesPath + "original_cosine_test.png");
expectedDctWatermarkedBitmap = new Bitmap(myResourcesPath + "cosine_watermarked_test.png");
expectedWatermarkedBitmap = new Bitmap(myResourcesPath + "dct_watermarked_test.png");
key = 10;
alpha = 0.01M;
parameters = new DctParameters(originalBitmap.TransformToEffectiveBitmap(), watermarkBitmap.TransformToEffectiveBitmap(), null, key, alpha);
algorithm = new Dct(parameters);
}
public Message GetActionDesc(BaseDCTAction action)
{
Message msg = null;
string command = GetCommandByAction(action);
if (command.Length > 0)
{
BaseModelFacade facade = new BaseModelFacade((SQLDomainDataProvider)DomainDataProviderManager.DomainDataProvider());
Dct dctAction = (Dct)facade.GetDCT(command);
if (dctAction != null)
{
msg = new Message("$DCT_CurrentDCTCommand " + dctAction.Dctdesc);
}
}
return(msg);
}
public double[,] Decompress(double[][] blocks, int dctSize, int imageHeight, int imageWidth, double[,] matrixQuantification)
{
var result = blocks
.AsParallel()
.AsOrdered()
.Select((block, index) =>
{
Console.WriteLine(Thread.CurrentThread.ManagedThreadId + " " + index);
var blockShiftValue = block.ShiftArrayValue(ShiftIndex);
var additionBlock = AdditionBlock(blockShiftValue, dctSize * dctSize - block.Length);
var matrix = _arrayToMatrixBuilder.Build(additionBlock, dctSize, dctSize);
var unQuantifiedMatrix = _quantifier.UnQuantification(matrix, matrixQuantification);
var unDctMatrix = Dct.Idct2D(unQuantifiedMatrix);
return(unDctMatrix);
})
.ToArray()
.MatrixBuildFromBlocks(imageHeight, imageWidth);
return(result);
}
public byte[][] Compress(double[,] matrix, int dctSize, int compressionLevel, double[,] matrixQuantification)
{
var dctBlocks = matrix
.DevideIntoBlocks(dctSize, dctSize)
.AsParallel()
.AsOrdered()
.Select(block =>
{
var dctMatrix = Dct.Dct2D(block);
var quantificationMatrix = _quantifier.Quantification(dctMatrix, matrixQuantification);
var transformedMatrix = _matrixToArrayTransformer.Transform(quantificationMatrix);
var blockShiftValue = transformedMatrix
.Take(compressionLevel)
.Select(shiftBlock => (byte)Math.Round(shiftBlock))
.ShiftArrayValue(ShiftIndex)
.ToArray();
return(blockShiftValue);
})
.ToArray();
return(dctBlocks);
}
public static void TestWhole()
{
// down sample
List <List <double> > data = new List <List <double> >();
for (int i = 0; i < bigtestdata.GetLength(0); i++)
{
if (i % 2 != 0)
{
continue;
}
List <double> row = new List <double>();
for (int j = 0; j < bigtestdata.GetLength(1); j++)
{
if (j % 2 != 0)
{
continue;
}
row.Add(bigtestdata[i, j]);
}
data.Add(row);
}
double[,] narr = new double[8, 8];
for (int i = 0; i < data.Count; i++)
{
for (int j = 0; j < data[i].Count; j++)
{
narr[i, j] = data[i][j];
}
}
print("Down Sampled");
narr.PrintArray();
Dct dct = new Dct();
var dctdata = dct.Go(narr);
print("dct go");
dctdata.PrintArray();
Quantizer.QuantizeLuminance(ref dctdata);
print("quantized");
dctdata.PrintArray();
var zagged = ZigZag.Run(dctdata);
var bzagged = zagged.Select(x => (sbyte)x).ToArray();
List <sbyte[]> zaglist = new List <sbyte[]>()
{
bzagged
};
sbyte[] rled = Rle.BetterEncode(zaglist);
// reversing
var unrle = Rle.DecodeRle(rled);
var unzag = ZigZag.Inverse(unrle[0].Select(x => (int)x).ToArray());
Quantizer.InverseQuantizeLuminance(ref unzag);
var idct = dct.GoBack(unzag);
idct.PrintArray();
}