internal void SaveAsImage(Stream stream, int width, int height, ImageWriterFormat format)
{
if (stream == null)
{
throw new ArgumentNullException("stream", "'stream' cannot be null (Nothing in Visual Basic)");
}
if (width <= 0)
{
throw new ArgumentOutOfRangeException("width", width, "'width' cannot be less than or equal to zero");
}
if (height <= 0)
{
throw new ArgumentOutOfRangeException("height", height, "'height' cannot be less than or equal to zero");
}
byte[] data = null;
try
{
data = new byte[width * height * 4];
GetData(data);
var writer = new ImageWriter();
writer.Write(data, width, height, 4, format, stream);
}
finally
{
if (data != null)
{
data = null;
}
}
}
private void menuFileExport_Click(object sender, EventArgs e)
{
if (mesh != null)
{
FormExport export = new FormExport();
string file = settings.OfdDirectory;
if (!file.EndsWith("\\"))
{
file += "\\";
}
file += settings.CurrentFile;
export.ImageName = Path.ChangeExtension(file, ".png");
if (export.ShowDialog() == DialogResult.OK)
{
int format = export.ImageFormat;
int size = export.ImageSize;
bool compress = export.UseCompression;
var writer = new ImageWriter();
writer.Export(this.mesh, export.ImageName, format, size, compress);
}
}
}
protected static void Align(ImageWriter strtab)
{
while (strtab.Position % 4 != 0)
{
strtab.WriteByte(0);
}
}
private static byte[] HashStream(Stream stream, ImageWriter writer, out int strong_name_pointer)
{
Section text = writer.text;
int headerSize = (int)writer.GetHeaderSize();
int pointerToRawData = (int)text.PointerToRawData;
DataDirectory strongNameSignatureDirectory = writer.GetStrongNameSignatureDirectory();
if (strongNameSignatureDirectory.Size == 0)
{
throw new InvalidOperationException();
}
strong_name_pointer = pointerToRawData + ((int)(strongNameSignatureDirectory.VirtualAddress - text.VirtualAddress));
int size = (int)strongNameSignatureDirectory.Size;
SHA1Managed transform = new SHA1Managed();
byte[] buffer = new byte[0x2000];
using (CryptoStream stream2 = new CryptoStream(Stream.Null, transform, CryptoStreamMode.Write))
{
stream.Seek(0L, SeekOrigin.Begin);
CopyStreamChunk(stream, stream2, buffer, headerSize);
stream.Seek((long)pointerToRawData, SeekOrigin.Begin);
CopyStreamChunk(stream, stream2, buffer, strong_name_pointer - pointerToRawData);
stream.Seek((long)size, SeekOrigin.Current);
CopyStreamChunk(stream, stream2, buffer, ((int)stream.Length) - (strong_name_pointer + size));
}
return(transform.Hash);
}
static byte [] HashStream (Stream stream, ImageWriter writer, out int strong_name_pointer)
{
const int buffer_size = 8192;
var text = writer.text;
var header_size = (int) writer.GetHeaderSize ();
var text_section_pointer = (int) text.PointerToRawData;
var strong_name_directory = writer.GetStrongNameSignatureDirectory ();
if (strong_name_directory.Size == 0)
throw new InvalidOperationException ();
strong_name_pointer = (int) (text_section_pointer
+ (strong_name_directory.VirtualAddress - text.VirtualAddress));
var strong_name_length = (int) strong_name_directory.Size;
var sha1 = new SHA1Managed ();
var buffer = new byte [buffer_size];
using (var crypto_stream = new CryptoStream (Stream.Null, sha1, CryptoStreamMode.Write)) {
stream.Seek (0, SeekOrigin.Begin);
CopyStreamChunk (stream, crypto_stream, buffer, header_size);
stream.Seek (text_section_pointer, SeekOrigin.Begin);
CopyStreamChunk (stream, crypto_stream, buffer, (int) strong_name_pointer - text_section_pointer);
stream.Seek (strong_name_length, SeekOrigin.Current);
CopyStreamChunk (stream, crypto_stream, buffer, (int) (stream.Length - (strong_name_pointer + strong_name_length)));
}
return sha1.Hash;
}
public MetadataWriter(AssemblyDefinition asm, MetadataRoot root,
AssemblyKind kind, TargetRuntime rt, BinaryWriter writer)
{
m_assembly = asm;
m_root = root;
m_runtime = rt;
m_imgWriter = new ImageWriter(this, kind, writer);
m_binaryWriter = m_imgWriter.GetTextWriter();
m_stringCache = new Hashtable();
m_stringWriter = new MemoryBinaryWriter(Encoding.UTF8);
m_stringWriter.Write((byte)0);
m_guidCache = new Hashtable();
m_guidWriter = new MemoryBinaryWriter();
m_usCache = new Hashtable();
m_usWriter = new MemoryBinaryWriter(Encoding.Unicode);
m_usWriter.Write((byte)0);
m_blobCache = new Hashtable(ByteArrayEqualityComparer.Instance, ByteArrayEqualityComparer.Instance);
m_blobWriter = new MemoryBinaryWriter();
m_blobWriter.Write((byte)0);
m_tWriter = new MemoryBinaryWriter();
m_tableWriter = new MetadataTableWriter(this, m_tWriter);
m_cilWriter = new MemoryBinaryWriter();
m_fieldDataWriter = new MemoryBinaryWriter();
m_resWriter = new MemoryBinaryWriter();
}
public void RegisterImages(ImageWriter imageWriter)
{
// NOTE: This mutates the images as they are registered, to account for trimming that RegisterImage does.
// (Kinda ugly, but too late to come up with something better.)
var cels = AllAnimations().SelectMany(a => a.Frames).SelectMany(f => f.layers);
foreach (var cel in cels)
{
var sprite = cel.spriteRef.ResolveRequire();
var newSprite = imageWriter.RegisterImage(sprite);
if (sprite != newSprite)
{
cel.spriteRef = new SpriteRef(newSprite);
}
}
if (shadowLayers != null)
{
for (int i = 0; i < shadowLayers.Count; i++)
{
var sl = shadowLayers[i];
var shadowSprite = sl.shadowSpriteRef.ResolveRequire();
var newShadowSprite = imageWriter.RegisterImage(shadowSprite);
if (shadowSprite != newShadowSprite)
{
sl.shadowSpriteRef = new SpriteRef(newShadowSprite);
shadowLayers[i] = sl;
}
}
}
}
static byte [] HashStream(Stream stream, ImageWriter writer, out int strong_name_pointer)
{
const int buffer_size = 8192;
var text = writer.text;
var header_size = (int)writer.GetHeaderSize();
var text_section_pointer = (int)text.PointerToRawData;
var strong_name_directory = writer.GetStrongNameSignatureDirectory();
if (strong_name_directory.Size == 0)
{
throw new InvalidOperationException();
}
strong_name_pointer = (int)(text_section_pointer
+ (strong_name_directory.VirtualAddress - text.VirtualAddress));
var strong_name_length = (int)strong_name_directory.Size;
var sha1 = new SHA1Managed();
var buffer = new byte [buffer_size];
using (var crypto_stream = new CryptoStream(Stream.Null, sha1, CryptoStreamMode.Write)) {
stream.Seek(0, SeekOrigin.Begin);
CopyStreamChunk(stream, crypto_stream, buffer, header_size);
stream.Seek(text_section_pointer, SeekOrigin.Begin);
CopyStreamChunk(stream, crypto_stream, buffer, (int)strong_name_pointer - text_section_pointer);
stream.Seek(strong_name_length, SeekOrigin.Current);
CopyStreamChunk(stream, crypto_stream, buffer, (int)(stream.Length - (strong_name_pointer + strong_name_length)));
}
return(sha1.Hash);
}
public void BasicExchangeEngineTest()
{
var tsfinder = new TileSetRepo.TileSetRepo();
tsfinder.Discover();
var tileset_stars = (IHueMatchingTileset)tsfinder.ByName("Stars (16x16)")[0];
var tileset_para16 = (IHueMatchingTileset)tsfinder.ByName("16 pastels (8x8)")[0];
var loader = new TesselatedImageLoader();
var tesser = new Basic16Tesselator();
var loaded_image = loader.LoadFromImagelibrary("green_leaf.jpg", tesser);
var writer = new ImageWriter();
var output_path = UserSettings.GetDefaultPath("output_path");
var assembled_bitmap_pre = loaded_image.AssembleFragments();
writer.WriteBitmap(assembled_bitmap_pre, System.IO.Path.Combine(output_path, "green_leaf_unchanged.jpg"));
new BasicExchangeEngine(tileset_stars, loaded_image).run();
var assembled_bitmap_stars = loaded_image.AssembleFragments();
writer.WriteBitmap(assembled_bitmap_stars, System.IO.Path.Combine(output_path, "stars_leaf_output.jpg"));
new BasicExchangeEngine(tileset_para16, loaded_image).run();
var assembled_bitmap_para16 = loaded_image.AssembleFragments();
writer.WriteBitmap(assembled_bitmap_para16, System.IO.Path.Combine(output_path, "parametric_leaf_output.jpg"));
}
public static void StrongName (Stream stream, ImageWriter writer, StrongNameKeyPair key_pair)
{
int strong_name_pointer;
var strong_name = CreateStrongName (key_pair, HashStream (stream, writer, out strong_name_pointer));
PatchStrongName (stream, strong_name_pointer, strong_name);
}
ISymbolWriter GetSymbolWriter(ModuleDefinition module, Disposable <Stream> stream)
{
var metadata = new MetadataBuilder(module, this);
var writer = ImageWriter.CreateDebugWriter(module, metadata, stream);
return(new PortablePdbWriter(metadata, module, writer));
}
private Pipeline CreateTilePipeline(Rectangle boundsOnResizedImage)
{
var tilePipeline = new Pipeline();
var fileCache = FileCache.GetInstance();
var fileName = _filePrefix + "_" + _tiles.Count + _fileExtension;
fileCache.RegisterPublicTempFileName(fileName, false);
tilePipeline.Add(new Crop(boundsOnResizedImage));
if ((_bitmapViewer.SourceImageParams.ColorProfile != null && _bitmapViewer.SourceImageParams.ColorProfile.ColorSpace == ColorSpace.Cmyk) ||
_bitmapViewer.SourceImageParams.PixelFormat.HasAlpha)
{
var cc = new Transforms.ColorConverter(PixelFormat.Format24bppRgb)
{
ColorManagementEngine =
ColorManagementEngine.LittleCms,
DestinationProfile = ColorProfile.FromSrgb()
};
tilePipeline.Add(cc);
}
tilePipeline.Add(ImageWriter.Create(fileCache.GetAbsolutePublicCachePath(fileName), _encoderOptions));
return(tilePipeline);
}
public static void StrongName(Stream stream, ImageWriter writer, StrongNameKeyPair key_pair)
{
int strong_name_pointer;
byte[] strong_name = CryptoService.CreateStrongName(key_pair, CryptoService.HashStream(stream, writer, out strong_name_pointer));
CryptoService.PatchStrongName(stream, strong_name_pointer, strong_name);
}
/// <summary>
/// Writes an image to disk taking the shader type into account
/// </summary>
/// <param name="index">The index in the file list</param>
/// <param name="type">The shader type</param>
/// <param name="folderName">An optional folder name to put the files into</param>
private void WriteImage(int index, ShaderType type, string folderName = "")
{
if (index < 0 || index >= _files.Count)
{
return;
}
if (!_files[index].Name.EndsWith(".bmp"))
{
return;
}
if (_files[index].Bytes == null)
{
return;
}
string pngName = _files[index].Name.Substring(0, _files[index].Name.Length - 3) + "png";
string exportPath = Path.GetFileNameWithoutExtension(_exportPath) + "/";
if (!string.IsNullOrEmpty(folderName))
{
exportPath += folderName;
}
var byteStream = new MemoryStream(_files[index].Bytes);
ImageWriter.WriteImage(byteStream, exportPath, pngName, type);
}
private void Given_Le64Header(uint cpu, uint loaders)
{
writer = new LeImageWriter(new byte[1000]);
writer.WriteLeUInt32(0xFEEDFACF);
WriteHeader(cpu, loaders);
writer.WriteLeUInt32(0); // reserved
}
public static void StrongName (Stream stream, ImageWriter writer, StrongNameKeyPair key_pair)
{
int strong_name_pointer;
var strong_name = CreateStrongName (key_pair, HashStream (stream, writer, out strong_name_pointer));
PatchStrongName (stream, strong_name_pointer, strong_name);
}
// Genetic Algorithm maxA testing method
public IEnumerator StartEvolution()
{
CHROMOSOME_SIZE = resolution * resolution;
// Initializing the population (we chose 500 genes for the population,
// but you can play with the population size to try different approaches)
InitializeAlgorithm(POPULATION_SIZE);
int generationCount = 0;
// For the sake of this sample, evolution goes on forever.
// If you wish the evolution to halt (for instance, after a number of
// generations is reached or the maximum fitness has been achieved),
// this is the place to make any such checks
while (generationCount < MAX_GENERATIONS)
{
// --- evaluate current generation:
EvaluateGeneration();
// --- print results here:
// we choose to print the average fitness,
// as well as the maximum and minimum fitness
// as part of our progress monitoring
float avgFitness = 0;
float minFitness = float.PositiveInfinity;
float maxFitness = float.NegativeInfinity;
Color[] bestIndividual = new Color[CHROMOSOME_SIZE];
Color[] worstIndividual;
for (int i = 0; i < Size(); i++)
{
float currFitness = GetGene(i).GetFitness();
avgFitness += currFitness;
if (currFitness < minFitness)
{
minFitness = currFitness;
worstIndividual = GetGene(i).GetPhenotype();
}
if (currFitness > maxFitness)
{
maxFitness = currFitness;
bestIndividual = GetGene(i).GetPhenotype();
}
}
if (Size() > 0)
{
avgFitness = avgFitness / Size();
}
string output = "Generation: " + generationCount;
output += "\t AvgFitness: " + avgFitness;
output += "\t MinFitness: " + minFitness; // + " (" + worstIndividual + ")";
output += "\t MaxFitness: " + maxFitness; // + " (" + bestIndividual + ")";
Debug.Log(output);
ImageWriter.WriteImage(resolution, bestIndividual, visualizer);
// produce next generation:
ProduceNextGeneration();
generationCount++;
yield return(null);
}
}
private static void TrackProgressAndCancel()
{
Console.WriteLine("ProgressAndCancel Sample\n");
Console.WriteLine("Press enter to start pipeline processing ");
Console.WriteLine("After start press \"c\" to cancel pipeline processing.");
Console.Read();
var cancelTokenSource = new CancellationTokenSource();
var cancelToken = cancelTokenSource.Token;
var task = Task.Factory.StartNew(() =>
{
// reader ---> resize ---> progress ---> writer
using (var reader = ImageReader.Create("../../../../_Input/Venice.jpg"))
using (var resize = new Resize(16000, 0, ResizeInterpolationMode.High))
using (var progress = new ProgressReporter())
using (var writer = ImageWriter.Create("../../../../_Output/TrackProgressAndCancel.jpg"))
{
progress.Progress += (s, e) =>
{
Console.WriteLine("{0:F2}%", e.Progress);
if (cancelToken.IsCancellationRequested == true)
{
Console.WriteLine("Pipeline processing was cancelled");
Console.WriteLine("\nPress \"x\" to quit");
cancelToken.ThrowIfCancellationRequested();
}
};
Console.WriteLine("Start cancellable pipeline processing...\n");
Pipeline.Run(reader + resize + progress + writer);
Console.WriteLine("\nEnd cancellable pipeline processing...");
Console.WriteLine("\nPress \"x\" to quit");
}
}, cancelToken);
var flag = true;
while (flag)
{
switch (Console.ReadKey().KeyChar)
{
case 'c':
cancelTokenSource.Cancel();
Console.WriteLine("Task cancellation requested.");
break;
case 'x':
flag = false;
break;
}
}
}
public static void StrongName(Stream stream, ImageWriter writer, WriterParameters parameters)
{
int strong_name_pointer;
var strong_name = CreateStrongName(parameters, HashStream(stream, writer, out strong_name_pointer));
PatchStrongName(stream, strong_name_pointer, strong_name);
}
/// <summary>
/// Loads and saves image to file using memory-friendly Pipeline API
/// </summary>
private static void LoadSaveFileMemoryFriendly()
{
using (var reader = ImageReader.Create("../../../../_Input/Chicago.jpg"))
using (var writer = ImageWriter.Create("../../../../_Output/LoadSaveFileMemoryFriendly.jpg"))
{
Pipeline.Run(reader + writer);
}
}
public void SaveToFile(string path)
{
using var stream = File.OpenWrite(path);
var image_writer = new ImageWriter();
image_writer.WritePng(pixel_data, Width, Height, ColorComponents.RedGreenBlueAlpha, stream);
}
// Lazy.
protected void LazyUpdate()
{
if (!NeedsUpdate)
{
return;
}
if (InputImageName is null ||
TileSet is null ||
!File.Exists(InputImageName))
{
NeedsUpdate = false;
return;
}
System.Console.WriteLine("TSR loaded {0} tilesets.", tsr.NumberOfTilesets());
try
{
var buffer = System.IO.File.ReadAllBytes(InputImageName);
var pixbuf = new Gdk.Pixbuf(buffer);
var image = new Gtk.Image(pixbuf);
foreach (var win in update_targets)
{
win.SetInputPixbuf(pixbuf);
}
}
catch (Exception exx)
{
System.Console.WriteLine("LazyUpdate could not update image, caused exception {0} for {1} ", exx.ToString(), InputImageName);
}
try
{
var tesser = new Basic16Tesselator();
var loader = new TesselatedImageLoader();
var loaded_image = loader.LoadFromImagelibrary(InputImageName, tesser);
var writer = new ImageWriter();
new TileExchange.BasicExchangeEngine((IHueMatchingTileset)TileSet, loaded_image).run();
var assembled_bitmap_pre = loaded_image.AssembleFragments();
writer.WriteBitmap(assembled_bitmap_pre, System.IO.Path.Combine("/tmp", "foo.png"));
MemoryStream ms = new MemoryStream();
assembled_bitmap_pre.Save(ms, ImageFormat.Png);
ms.Position = 0;
var pixbuf = new Gdk.Pixbuf(ms);
update_targets[0].SetOutputPixbuf(pixbuf);
}
catch (Exception exx)
{
System.Console.WriteLine("LazyUpdate could not generate image, caused exception {0} for {1} ", exx.ToString(), InputImageName);
}
}
/// <summary>
/// Returns a string containing an OBJ export for this mesh
/// </summary>
/// <param name="forceMaterialList">Forces the export to use a specific material list - e.g. model head</param>
/// <returns>The OBJ export</returns>
public string GetSkeletonMeshExport(string forceMaterialList = null)
{
var export = new StringBuilder();
export.AppendLine(LanternStrings.ObjMaterialHeader + (string.IsNullOrEmpty(forceMaterialList)
? FixCharacterMeshName(Name, true)
: FixCharacterMeshName(forceMaterialList, true)) + LanternStrings.FormatMtlExtension);
for (var i = 0; i < Vertices.Count; i++)
{
vec3 vertex = Vertices[i];
vec2 uvs = TextureUvCoordinates[i];
export.AppendLine("v " + (vertex.x + Center.x) + " " + (vertex.y + Center.y) + " " +
(vertex.z + Center.z));
export.AppendLine("vt " + uvs.x + " " + uvs.y);
}
int currentPolygon = 0;
foreach (RenderGroup group in RenderGroups)
{
string bitmapName = MaterialList.Materials[group.TextureIndex].TextureInfoReference.TextureInfo
.BitmapNames[0].Filename;
if (bitmapName.ToLower().StartsWith("chain"))
{
}
string slotName = string.Empty;
slotName = MaterialList.Materials[group.TextureIndex].ExportName;
string pngName = bitmapName.Substring(0, bitmapName.Length - 4);
string materialName =
ImageWriter.GetExportedImageName(pngName, MaterialList.Materials[group.TextureIndex].ShaderType);
export.AppendLine(LanternStrings.ObjUseMtlPrefix + slotName);
for (int i = 0; i < group.PolygonCount; ++i)
{
int vertex1 = Polygons[currentPolygon].Vertex1 + 1;
int vertex2 = Polygons[currentPolygon].Vertex2 + 1;
int vertex3 = Polygons[currentPolygon].Vertex3 + 1;
export.AppendLine("f " + vertex3 + "/" + vertex3 + " "
+ vertex2 + "/" + vertex2 + " " +
+vertex1 + "/" + vertex1);
currentPolygon++;
}
}
// Ensure that output use the decimal point rather than the comma (as in Germany)
string exportString = export.ToString().Replace(',', '.');
return(exportString);
}
/// <summary>
/// This method deletes a 'Image' object.
/// </summary>
/// <param name='List<PolymorphicObject>'>The 'Image' to delete.
/// <returns>A PolymorphicObject object with a Boolean value.
internal PolymorphicObject DeleteImage(List <PolymorphicObject> parameters, DataConnector dataConnector)
{
// Initial Value
PolymorphicObject returnObject = new PolymorphicObject();
// If the data connection is connected
if ((dataConnector != null) && (dataConnector.Connected == true))
{
// Create Delete StoredProcedure
DeleteImageStoredProcedure deleteImageProc = null;
// verify the first parameters is a(n) 'Image'.
if (parameters[0].ObjectValue as Image != null)
{
// Create Image
Image image = (Image)parameters[0].ObjectValue;
// verify image exists
if (image != null)
{
// Now create deleteImageProc from ImageWriter
// The DataWriter converts the 'Image'
// to the SqlParameter[] array needed to delete a 'Image'.
deleteImageProc = ImageWriter.CreateDeleteImageStoredProcedure(image);
}
}
// Verify deleteImageProc exists
if (deleteImageProc != null)
{
// Execute Delete Stored Procedure
bool deleted = this.DataManager.ImageManager.DeleteImage(deleteImageProc, dataConnector);
// Create returnObject.Boolean
returnObject.Boolean = new NullableBoolean();
// If delete was successful
if (deleted)
{
// Set returnObject.Boolean.Value to true
returnObject.Boolean.Value = NullableBooleanEnum.True;
}
else
{
// Set returnObject.Boolean.Value to false
returnObject.Boolean.Value = NullableBooleanEnum.False;
}
}
}
else
{
// Raise Error Data Connection Not Available
throw new Exception("The database connection is not available.");
}
// return value
return(returnObject);
}
public void ShouldGetImageBytes()
{
var reader = new SegyReader();
var segy = reader.Read(@"./Examples/lineE.sgy");
var imageWriter = new ImageWriter();
var bytes = imageWriter.GetRaw32BppRgba(segy.Traces);
var expected = 4 * segy.Traces.Count * segy.Traces[0].Values.Count;
Assert.That(bytes.Length, Is.EqualTo(expected));
}
/// <summary>
/// Removes alpha channel using memory-friendly Pipeline API
/// </summary>
private static void RemoveAlphaChannelMemoryFriendly()
{
using (var reader = ImageReader.Create("../../../../_Input/Stamp.png"))
using (var removeAlpha = new RemoveAlpha())
using (var writer = ImageWriter.Create("../../../../_Output/RemoveAlphaChannelMemoryFriendly.png"))
{
Pipeline.Run(reader + removeAlpha + writer);
}
}
/// <summary>
/// Loads and saves image to file with specified encoder options using alternative syntax and memory-friendly Pipeline API
/// </summary>
private static void LoadSaveFileAltSyntaxMemoryFriendly()
{
using (var reader = ImageReader.Create("../../../../_Input/Chicago.jpg"))
// Set value of JPEG quality to 85
using (var writer = ImageWriter.Create("../../../../_Output/LoadSaveFileAltSyntaxMemoryFriendly.jpg", new JpegSettings(85)))
{
Pipeline.Run(reader + writer);
}
}
/// <summary>
/// Adjusts brightness modifying all channels of RGB color space
/// </summary>
private static void AdjustLightnessRgb()
{
using (var reader = ImageReader.Create("../../../../_Input/Chicago.jpg"))
using (var brightness = new Brightness(brightnessAmount))
using (var writer = ImageWriter.Create("../../../../_Output/AdjustLightnessRgb.jpg"))
{
Pipeline.Run(reader + brightness + writer);
}
}
/// <summary>
/// Resizes image using memory-friendly Pipeline API
/// </summary>
private static void ResizeMemoryFriendly()
{
using (var reader = ImageReader.Create("../../../../_Input/Chicago.jpg"))
using (var resize = new Resize(320, 0, ResizeInterpolationMode.High))
using (var writer = ImageWriter.Create("../../../../_Output/ResizeMemoryFriendly.jpg"))
{
Pipeline.Run(reader + resize + writer);
}
}
/// <summary>
/// Warps image using memory-friendly Pipeline API
/// </summary>
private static void BezierMemoryFriendly()
{
using (var reader = ImageReader.Create("../../../../_Input/Chicago.jpg"))
using (var bezier = new BezierTransform(ControlPoints, RgbColor.Transparent, InterpolationMode.High))
using (var writer = ImageWriter.Create("../../../../_Output/BezierMemoryFriendly.jpg"))
{
Pipeline.Run(reader + bezier + writer);
}
}
/// <summary>
/// Flips image using memory-friendly Pipeline API
/// </summary>
private static void FlipMemoryFriendly()
{
using (var reader = ImageReader.Create("../../../../_Input/Chicago.jpg"))
using (var flip = new Flip(FlipType.Vertical))
using (var writer = ImageWriter.Create("../../../../_Output/FlipMemoryFriendly.jpg"))
{
Pipeline.Run(reader + flip + writer);
}
}
/// <summary>
/// Rotates image on arbitrary angle using memory-friendly Pipeline API
/// </summary>
private static void RotateArbitraryMemoryFriendly()
{
using (var reader = ImageReader.Create("../../../../_Input/Chicago.jpg"))
using (var rotate = new Rotate(15, RgbColor.Yellow, InterpolationMode.High))
using (var writer = ImageWriter.Create("../../../../_Output/RotateArbitraryMemoryFriendly.jpg"))
{
Pipeline.Run(reader + rotate + writer);
}
}
/// <summary>
/// Rotates image on 90, 180, 270 degrees image using memory-friendly Pipeline API
/// </summary>
private static void RotateMemoryFriendly()
{
using (var reader = ImageReader.Create("../../../../_Input/Chicago.jpg"))
using (var rotate = new Rotate(90))
using (var writer = ImageWriter.Create("../../../../_Output/RotateMemoryFriendly.jpg"))
{
Pipeline.Run(reader + rotate + writer);
}
}
public static int Main(string[] args)
{
if( args.Length < 2 )
{
System.Console.WriteLine( " input.dcm output.dcm" );
return 1;
}
string filename = args[0];
string outfilename = args[1];
ImageReader reader = new ImageReader();
reader.SetFileName( filename );
if( !reader.Read() )
{
System.Console.WriteLine( "Could not read: " + filename );
return 1;
}
// The output of gdcm::Reader is a gdcm::File
File file = reader.GetFile();
// the dataset is the the set of element we are interested in:
DataSet ds = file.GetDataSet();
Image image = reader.GetImage();
//image.Print( cout );
ImageChangeTransferSyntax change = new ImageChangeTransferSyntax();
TransferSyntax targetts = new TransferSyntax( TransferSyntax.TSType.JPEGBaselineProcess1 );
change.SetTransferSyntax( targetts );
// Setup our JPEGCodec, warning it should be compatible with JPEGBaselineProcess1
JPEGCodec jpegcodec = new JPEGCodec();
if( !jpegcodec.CanCode( targetts ) )
{
System.Console.WriteLine( "Something went really wrong, JPEGCodec cannot handle JPEGBaselineProcess1" );
return 1;
}
jpegcodec.SetLossless( false );
jpegcodec.SetQuality( 50 ); // poor quality !
change.SetUserCodec( jpegcodec ); // specify the codec to use to the ImageChangeTransferSyntax
change.SetInput( image );
bool b = change.Change();
if( !b )
{
System.Console.WriteLine( "Could not change the Transfer Syntax" );
return 1;
}
ImageWriter writer = new ImageWriter();
writer.SetImage( change.GetOutput() );
writer.SetFile( reader.GetFile() );
writer.SetFileName( outfilename );
if( !writer.Write() )
{
System.Console.WriteLine( "Could not write: " + outfilename );
return 1;
}
return 0;
}
private void Render(Canvas canvas, string outputPath)
{
canvas.RenderCanvas();
var width = 0;
var height = 0;
foreach (var control in canvas.Children)
RenderBounds(control, ref width, ref height);
var imageSettings = new Settings { Height = (ushort)height, Width = (ushort)width };
var renderBuffer = RenderDevice.Backend.CreateRenderBuffer(imageSettings);
renderBuffer.CreateRenderBuffer(RenderBufferType.Color);
renderBuffer.CreateRenderBuffer(RenderBufferType.Depth);
renderBuffer.Context = MainWindow.Context;
MainView.RenderTarget = renderBuffer;
MainView.Size = new Vector2i(width, height);
canvas.SetSize(width, height);
RenderDevice.ActiveView = MainView;
if (!renderBuffer.Check())
throw new Exception("Error creating render buffer");
renderBuffer.Bind();
var rb = new RenderBlock();
Renderer.Render(rb);
RenderDevice.ClearView();
RenderDevice.Render(rb);
Engine.StepFrame();
var image = renderBuffer.ReadImage(1);
var imageWriter = new ImageWriter();
imageWriter.Save(image, outputPath);
renderBuffer.Unbind();
}
public static int Main(string[] args)
{
string file1 = args[0];
Mpeg2VideoInfo info = new Mpeg2VideoInfo(file1);
System.Console.WriteLine( info.StartTime );
System.Console.WriteLine( info.EndTime );
System.Console.WriteLine( info.Duration );
System.Console.WriteLine( info.AspectRatio );
System.Console.WriteLine( info.FrameRate );
System.Console.WriteLine( info.PictureWidth );
System.Console.WriteLine( info.PictureHeight );
ImageReader r = new ImageReader();
//Image image = new Image();
Image image = r.GetImage();
image.SetNumberOfDimensions( 3 );
DataElement pixeldata = new DataElement( new gdcm.Tag(0x7fe0,0x0010) );
System.IO.FileStream infile =
new System.IO.FileStream(file1, System.IO.FileMode.Open, System.IO.FileAccess.Read);
uint fsize = gdcm.PosixEmulation.FileSize(file1);
byte[] jstream = new byte[fsize];
infile.Read(jstream, 0 , jstream.Length);
SmartPtrFrag sq = SequenceOfFragments.New();
Fragment frag = new Fragment();
frag.SetByteValue( jstream, new gdcm.VL( (uint)jstream.Length) );
sq.AddFragment( frag );
pixeldata.SetValue( sq.__ref__() );
// insert:
image.SetDataElement( pixeldata );
PhotometricInterpretation pi = new PhotometricInterpretation( PhotometricInterpretation.PIType.YBR_PARTIAL_420 );
image.SetPhotometricInterpretation( pi );
// FIXME hardcoded:
PixelFormat pixeltype = new PixelFormat(3,8,8,7);
image.SetPixelFormat( pixeltype );
// FIXME hardcoded:
TransferSyntax ts = new TransferSyntax( TransferSyntax.TSType.MPEG2MainProfile);
image.SetTransferSyntax( ts );
image.SetDimension(0, (uint)info.PictureWidth);
image.SetDimension(1, (uint)info.PictureHeight);
image.SetDimension(2, 721);
ImageWriter writer = new ImageWriter();
gdcm.File file = writer.GetFile();
file.GetHeader().SetDataSetTransferSyntax( ts );
Anonymizer anon = new Anonymizer();
anon.SetFile( file );
MediaStorage ms = new MediaStorage( MediaStorage.MSType.VideoEndoscopicImageStorage);
UIDGenerator gen = new UIDGenerator();
anon.Replace( new Tag(0x0008,0x16), ms.GetString() );
anon.Replace( new Tag(0x0018,0x40), "25" );
anon.Replace( new Tag(0x0018,0x1063), "40.000000" );
anon.Replace( new Tag(0x0028,0x34), "4\\3" );
anon.Replace( new Tag(0x0028,0x2110), "01" );
writer.SetImage( image );
writer.SetFileName( "dummy.dcm" );
if( !writer.Write() )
{
System.Console.WriteLine( "Could not write" );
return 1;
}
return 0;
}
public void ShouldReturnEmptyArrayForNoTraces()
{
var bytes = new ImageWriter().GetRaw32BppRgba(new ITrace[]{});
Assert.That(bytes.Length, Is.EqualTo(0));
}
void Render(string outputPath)
{
var width = 0;
var height = 0;
foreach (var control in guiRenderable.Canvas.Children)
RenderBounds(control, ref width, ref height);
app.RunStep();
var imageSettings = new Settings { Height = (ushort)height, Width = (ushort)width };
var renderBuffer = app.RenderDevice.Backend.CreateRenderBuffer(imageSettings);
renderBuffer.CreateRenderBuffer(RenderBufferType.Color);
renderBuffer.CreateRenderBuffer(RenderBufferType.Depth);
renderBuffer.Context = window.RenderContext;
window.view.ClearColor = Color.White;
window.view.RenderTarget = renderBuffer;
window.view.Size = new Vector2i(width, height);
guiRenderable.Canvas.SetSize(width, height);
window.device.ActiveView = window.view;
if (!renderBuffer.Check())
throw new Exception("Error creating render buffer");
renderBuffer.Bind();
window.Render();
var image = renderBuffer.ReadImage(1);
var imageWriter = new ImageWriter();
imageWriter.Save(image, outputPath);
renderBuffer.Unbind();
}
public static int Main(string[] args)
{
string file1 = args[0];
string file2 = args[1];
ImageReader reader = new ImageReader();
reader.SetFileName( file1 );
bool ret = reader.Read();
if( !ret )
{
return 1;
}
Image image = new Image();
Image ir = reader.GetImage();
image.SetNumberOfDimensions( ir.GetNumberOfDimensions() );
//Just for fun:
//int dircos = ir.GetDirectionCosines();
//t = gdcm.Orientation.GetType(dircos);
//int l = gdcm.Orientation.GetLabel(t);
//System.Console.WriteLine( "Orientation label:" + l );
// Set the dimensions,
// 1. either one at a time
//image.SetDimension(0, ir.GetDimension(0) );
//image.SetDimension(1, ir.GetDimension(1) );
// 2. the array at once
uint[] dims = {0, 0};
// Just for fun let's invert the dimensions:
dims[0] = ir.GetDimension(1);
dims[1] = ir.GetDimension(0);
ir.SetDimensions( dims );
PixelFormat pixeltype = ir.GetPixelFormat();
image.SetPixelFormat( pixeltype );
PhotometricInterpretation pi = ir.GetPhotometricInterpretation();
image.SetPhotometricInterpretation( pi );
DataElement pixeldata = new DataElement( new Tag(0x7fe0,0x0010) );
byte[] str1 = new byte[ ir.GetBufferLength()];
ir.GetBuffer( str1 );
//System.Console.WriteLine( ir.GetBufferLength() );
pixeldata.SetByteValue( str1, new VL( (uint)str1.Length ) );
//image.SetDataElement( pixeldata );
ir.SetDataElement( pixeldata );
ImageWriter writer = new ImageWriter();
writer.SetFileName( file2 );
writer.SetFile( reader.GetFile() );
writer.SetImage( ir );
ret = writer.Write();
if( !ret )
{
return 1;
}
return 0;
}
public override void onImageReleased(ImageWriter writer)
{
Log.d(TAG, "onImageReleased");
}
public static int Main(string[] args)
{
string filename = args[0];
// instanciate the reader:
gdcm.ImageReader reader = new gdcm.ImageReader();
reader.SetFileName( filename );
if (!reader.Read()) return 1;
Image ir = reader.GetImage();
uint[] dims = {0, 0, 0};
dims[0] = ir.GetDimension(0);
dims[1] = ir.GetDimension(1);
dims[2] = ir.GetDimension(2);
System.Console.WriteLine( "Dim:" + dims[0] );
System.Console.WriteLine( "Dim:" + dims[1] );
System.Console.WriteLine( "Dim:" + dims[2] );
// buffer to get the pixels
byte[] buffer = new byte[ ir.GetBufferLength()];
System.Console.WriteLine( "Dim:" + ir.GetBufferLength() );
ir.GetBuffer( buffer );
for (uint z = 0; z < dims[2]; z++)
{
for (uint y = 0; y < dims[1] / 2; y++) // only half Y
{
for (uint x = 0; x < dims[0] / 2; x++) // only half X
{
buffer[ (z * dims[1] + y) * dims[0] + x ] = 0; // works when pixel type == UINT8
}
}
}
DataElement pixeldata = new DataElement( new Tag(0x7fe0,0x0010) );
pixeldata.SetByteValue( buffer, new VL( (uint)buffer.Length ) );
ir.SetDataElement( pixeldata );
ir.SetTransferSyntax( new TransferSyntax( TransferSyntax.TSType.ExplicitVRLittleEndian ) );
ImageChangeTransferSyntax change = new ImageChangeTransferSyntax();
change.SetTransferSyntax( new TransferSyntax( TransferSyntax.TSType.JPEGLSLossless ) );
change.SetInput( ir );
if( !change.Change() )
{
System.Console.WriteLine( "Could not change: " + filename );
return 1;
}
ImageWriter writer = new ImageWriter();
writer.SetFileName( "out.dcm" );
writer.SetFile( reader.GetFile() );
writer.SetImage( change.GetOutput() );
bool ret = writer.Write();
if( !ret )
{
return 1;
}
return 0;
}
