#include "Stdafx.h"

#include "Helpers\FileHelper.h"

#include "MagickImage.h"

#include "MagickImageCollection.h"

#include "Quantum.h"

using namespace System::Globalization;

namespace GraphicsMagick

{

//==============================================================================================

Magick::Image* MagickImage::CreateImage()

{

Magick::Image* image = new Magick::Image();

return image;

}

//==============================================================================================

template<class TImageProfile>

TImageProfile^ MagickImage::CreateProfile(String^ name)

{

Throw::IfNullOrEmpty("name", name);

try

{

std::string profileName;

Marshaller::Marshal(name, profileName);

Magick::Blob blob = Value->profile(profileName);

array<Byte>^ data = Marshaller::Marshal(&blob);

if (data == nullptr)

return nullptr;

TImageProfile^ result = gcnew TImageProfile();

result->Initialize(data);

result->Initialize(this);

return result;

}

catch(Magick::ErrorCoder)

{

return nullptr;

}

catch(Magick::Exception& exception)

{

HandleException(exception);

}

}

//==============================================================================================

unsigned char* MagickImage::ExportPixels(String^ map)

{

void* result = malloc(map->Length * Width * Height * sizeof(unsigned char*));

std::string magickMap;

Marshaller::Marshal(map, magickMap);

MagickLib::ExceptionInfo exceptionInfo;

MagickLib::GetExceptionInfo(&exceptionInfo);

(void) DispatchImage(Value->image(), 0, 0, Width, Height, magickMap.c_str(),

(Magick::StorageType)StorageType::Char, result, &exceptionInfo);

Magick::throwException(exceptionInfo);

MagickLib::DestroyExceptionInfo(&exceptionInfo);

return (unsigned char*)result;

}

//==============================================================================================

String^ MagickImage::FormatedFileSize()

{

Decimal fileSize = FileSize;

String^ suffix = "";

if (fileSize > 1073741824)

{

fileSize /= 1073741824;

suffix = "GB";

}

else if (fileSize > 1048576)

{

fileSize /= 1048576;

suffix = "MB";

}

else if (fileSize > 1024)

{

fileSize /= 1024;

suffix = "kB";

}

return String::Format(CultureInfo::InvariantCulture, "{0:N2}{1}", fileSize, suffix);

}

//==============================================================================================

MagickFormat MagickImage::GetCoderFormat(MagickFormat format)

}

//==============================================================================================

void MagickImage::HandleException(const Magick::Exception& exception)

{

HandleException(MagickException::Create(exception));

}

//==============================================================================================

void MagickImage::HandleException(MagickException^ exception)

{

if (exception == nullptr)

return;

MagickWarningException^ warning = dynamic_cast<MagickWarningException^>(exception);

if (warning == nullptr)

throw exception;

if (_WarningEvent != nullptr)

_WarningEvent->Invoke(this, gcnew WarningEventArgs(warning));

}

//==============================================================================================

bool MagickImage::IsSupportedImageFormat(ImageFormat^ format)

{

return

format->Guid.Equals(ImageFormat::Bmp->Guid) ||

format->Guid.Equals(ImageFormat::Gif->Guid) ||

format->Guid.Equals(ImageFormat::Icon->Guid) ||

format->Guid.Equals(ImageFormat::Jpeg->Guid) ||

format->Guid.Equals(ImageFormat::Png->Guid) ||

format->Guid.Equals(ImageFormat::Tiff->Guid);

}

//==============================================================================================

void MagickImage::RaiseOrLower(int size, bool raiseFlag)

}

//==============================================================================================

void MagickImage::RandomThreshold(Magick::Quantum low, Magick::Quantum high, bool isPercentage)

}

//==============================================================================================

void MagickImage::RandomThreshold(Magick::Quantum low, Magick::Quantum high, Channels channels, bool isPercentage)

}

//==============================================================================================

void MagickImage::SetFormat(ImageFormat^ format)

{

if (format == ImageFormat::Bmp)

Format = MagickFormat::Bmp;

else if (format == ImageFormat::Gif)

Format = MagickFormat::Gif;

else if (format == ImageFormat::Jpeg)

Format = MagickFormat::Jpeg;

else if (format == ImageFormat::Png)

Format = MagickFormat::Png;

else if (format == ImageFormat::Tiff)

Format = MagickFormat::Tiff;

else

throw gcnew NotSupportedException("Unsupported image format: " + format->ToString());

}

//==============================================================================================

void MagickImage::SetProfile(String^ name, Magick::Blob& blob)

{

Throw::IfNullOrEmpty("name", name);

try

{

std::string profileName;

Marshaller::Marshal(name, profileName);

Value->profile(profileName, blob);

}

catch(Magick::Exception& exception)

{

HandleException(exception);

}

}

//==============================================================================================

MagickImage::MagickImage(const Magick::Image& image)

{

Value = new Magick::Image(image);

}

//==============================================================================================

void MagickImage::Apply(QuantizeSettings^ settings)

{

Value->quantizeColors(settings->Colors);

Value->quantizeColorSpace((Magick::ColorspaceType)settings->ColorSpace);

Value->quantizeDither(settings->Dither);

Value->quantizeTreeDepth(settings->TreeDepth);

}

//==============================================================================================

const Magick::Image& MagickImage::ReuseValue()

{

return *Value;

}

//==============================================================================================

MagickImage::MagickImage()

{

Value = CreateImage();

}

//==============================================================================================

MagickImage::MagickImage(array<Byte>^ data)

{

Value = CreateImage();

this->Read(data);

}

//==============================================================================================

MagickImage::MagickImage(array<Byte>^ data, MagickReadSettings^ readSettings)

{

Value = CreateImage();

this->Read(data, readSettings);

}

//==============================================================================================

MagickImage::MagickImage(Bitmap^ bitmap)

{

Value = CreateImage();

this->Read(bitmap);

}

//==============================================================================================

MagickImage::MagickImage(FileInfo^ file)

{

Value = CreateImage();

this->Read(file);

}

//==============================================================================================

MagickImage::MagickImage(FileInfo^ file, MagickReadSettings^ readSettings)

{

Value = CreateImage();

this->Read(file, readSettings);

}

//==============================================================================================

MagickImage::MagickImage(MagickColor^ color, int width, int height)

{

Value = CreateImage();

this->Read(color, width, height);

}

//==============================================================================================

MagickImage::MagickImage(MagickImage^ image)

{

Throw::IfNull("image", image);

Value = new Magick::Image(*image->Value);

}

//==============================================================================================

MagickImage::MagickImage(String^ fileName)

{

Value = new Magick::Image();

this->Read(fileName);

}

//==============================================================================================

MagickImage::MagickImage(String^ fileName, int width, int height)

{

Value = new Magick::Image();

this->Read(fileName, width, height);

}

//==============================================================================================

MagickImage::MagickImage(String^ fileName, MagickReadSettings^ readSettings)

{

Value = new Magick::Image();

this->Read(fileName, readSettings);

}

//==============================================================================================

MagickImage::MagickImage(Stream^ stream)

{

Value = new Magick::Image();

this->Read(stream);

}

//==============================================================================================

MagickImage::MagickImage(Stream^ stream, MagickReadSettings^ readSettings)

{

Value = new Magick::Image();

this->Read(stream, readSettings);

}

//==============================================================================================

bool MagickImage::Adjoin::get()

{

return Value->adjoin();

}

//==============================================================================================

void MagickImage::Adjoin::set(bool value)

{

Value->adjoin(value);

}

//==============================================================================================

int MagickImage::AnimationDelay::get()

{

return Convert::ToInt32(Value->animationDelay());

}

//==============================================================================================

void MagickImage::AnimationDelay::set(int value)

{

Value->animationDelay(value);

}

//==============================================================================================

int MagickImage::AnimationIterations::get()

{

return Convert::ToInt32(Value->animationIterations());

}

//==============================================================================================

void MagickImage::AnimationIterations::set(int value)

{

Value->animationIterations(value);

}

//==============================================================================================

bool MagickImage::AntiAlias::get()

{

return Value->antiAlias();

}

//==============================================================================================

void MagickImage::AntiAlias::set(bool value)

{

Value->antiAlias(value);

}

//==============================================================================================

MagickColor^ MagickImage::BackgroundColor::get()

{

return gcnew MagickColor(Value->backgroundColor());

}

//==============================================================================================

void MagickImage::BackgroundColor::set(MagickColor^ value)

{

const Magick::Color* color = ReferenceEquals(value, nullptr) ? new Magick::Color() : value->CreateColor();

Value->backgroundColor(*color);

delete color;

}

//==============================================================================================

int MagickImage::BaseHeight::get()

{

return Convert::ToInt32(Value->baseRows());

}

//==============================================================================================

int MagickImage::BaseWidth::get()

{

return Convert::ToInt32(Value->baseColumns());

}

//==============================================================================================

MagickGeometry^ MagickImage::BoundingBox::get()

{

try

{

return gcnew MagickGeometry(Value->boundingBox());

}

catch(Magick::WarningOption)

{

return nullptr;

}

catch(Magick::Exception& exception)

{

HandleException(exception);

}

}

//==============================================================================================

MagickColor^ MagickImage::BorderColor::get()

{

return gcnew MagickColor(Value->borderColor());

}

//==============================================================================================

void MagickImage::BorderColor::set(MagickColor^ value)

{

const Magick::Color* color = ReferenceEquals(value, nullptr) ? new Magick::Color() : value->CreateColor();

Value->borderColor(*color);

delete color;

}

//==============================================================================================

MagickColor^ MagickImage::BoxColor::get()

{

return gcnew MagickColor(Value->boxColor());

}

//==============================================================================================

void MagickImage::BoxColor::set(MagickColor^ value)

{

const Magick::Color* color = ReferenceEquals(value, nullptr) ? new Magick::Color() : value->CreateColor();

Value->boxColor(*color);

delete color;

}

//==============================================================================================

ClassType MagickImage::ClassType::get()

{

return (GraphicsMagick::ClassType)Value->classType();

}

//==============================================================================================

void MagickImage::ClassType::set(GraphicsMagick::ClassType value)

{

return Value->classType((Magick::ClassType)value);

}

//==============================================================================================

MagickImage^ MagickImage::ClipMask::get()

{

Magick::Image clipMask = Value->clipMask();

if (!clipMask.isValid())

return nullptr;

return gcnew MagickImage(clipMask);

}

//==============================================================================================

void MagickImage::ClipMask::set(MagickImage^ value)

{

if (value == nullptr)

{

Magick::Image* image = new Magick::Image();

Value->clipMask(*image);

delete image;

}

else

{

Value->clipMask(*value->Value);

}

}

//==============================================================================================

Percentage MagickImage::ColorFuzz::get()

{

return Percentage::FromQuantum(Value->colorFuzz());

}

//==============================================================================================

void MagickImage::ColorFuzz::set(Percentage value)

{

Value->colorFuzz(value.ToQuantum());

}

//==============================================================================================

int MagickImage::ColorMapSize::get()

{

int colorMapSize = -1;

try

{

colorMapSize = Convert::ToInt32(Value->colorMapSize());

}

catch(Magick::ErrorOption)

{

}

catch(Magick::Exception& exception)

{

HandleException(exception);

}

return colorMapSize;

}

//==============================================================================================

void MagickImage::ColorMapSize::set(int value)

{

Value->colorMapSize(value);

}

//==============================================================================================

ColorSpace MagickImage::ColorSpace::get()

{

return (GraphicsMagick::ColorSpace)Value->colorSpace();

}

//==============================================================================================

void MagickImage::ColorSpace::set(GraphicsMagick::ColorSpace value)

{

try

{

Value->colorSpace((Magick::ColorspaceType)value);

}

catch(Magick::Exception& exception)

{

HandleException(exception);

}

}

//==============================================================================================

ColorType MagickImage::ColorType::get()

{

return (GraphicsMagick::ColorType)Value->type();

}

//==============================================================================================

void MagickImage::ColorType::set(GraphicsMagick::ColorType value)

{

Value->type((Magick::ImageType)value);

}

//==============================================================================================

String^ MagickImage::Comment::get()

{

return Marshaller::Marshal(Value->comment());

}

//==============================================================================================

void MagickImage::Comment::set(String^ value)

{

std::string comment;

Value->comment(Marshaller::Marshal(value, comment));

}

//==============================================================================================

CompositeOperator MagickImage::Compose::get()

{

return (CompositeOperator)Value->compose();

}

//==============================================================================================

void MagickImage::Compose::set(CompositeOperator value)

{

Value->compose((Magick::CompositeOperator)value);

}

//==============================================================================================

CompressionMethod MagickImage::CompressionMethod::get()

{

return (GraphicsMagick::CompressionMethod)Value->compressType();

}

//==============================================================================================

void MagickImage::CompressionMethod::set(GraphicsMagick::CompressionMethod value)

{

Value->compressType((Magick::CompressionType)value);

}

//==============================================================================================

bool MagickImage::Debug::get()

{

return Value->debug();

}

//==============================================================================================

void MagickImage::Debug::set(bool value)

{

Value->debug(value);

}

//==============================================================================================

MagickGeometry^ MagickImage::Density::get()

{

return gcnew MagickGeometry(Value->density());

}

//==============================================================================================

void MagickImage::Density::set(MagickGeometry^ value)

{

if (value == nullptr)

return;

const Magick::Geometry* geometry = value->CreateGeometry();

Value->density(*geometry);

delete geometry;

if (ResolutionUnits == Resolution::Undefined)

ResolutionUnits = Resolution::PixelsPerInch;

}

//==============================================================================================

int MagickImage::Depth::get()

{

return Convert::ToInt32(Value->depth());

}

//==============================================================================================

void MagickImage::Depth::set(int value)

{

Value->depth(value);

}

//==============================================================================================

Endian MagickImage::Endian::get()

{

return (GraphicsMagick::Endian)Value->endian();

}

//==============================================================================================

void MagickImage::Endian::set(GraphicsMagick::Endian value)

{

Value->endian((Magick::EndianType)value);

}

//==============================================================================================

int MagickImage::FileSize::get()

{

return Value->fileSize();

}

//==============================================================================================

String^ MagickImage::FileName::get()

{

return Marshaller::Marshal(Value->baseFilename());

}

//==============================================================================================

MagickColor^ MagickImage::FillColor::get()

{

return gcnew MagickColor(Value->fillColor());

}

//==============================================================================================

void MagickImage::FillColor::set(MagickColor^ value)

{

const Magick::Color* color = ReferenceEquals(value, nullptr) ? new Magick::Color() : value->CreateColor();

Value->fillColor(*color);

delete color;

}

//==============================================================================================

MagickImage^ MagickImage::FillPattern::get()

{

Magick::Image fillPattern = Value->fillPattern();

if (!fillPattern.isValid())

return nullptr;

return gcnew MagickImage(fillPattern);

}

//==============================================================================================

void MagickImage::FillPattern::set(MagickImage^ value)

{

if (value == nullptr)

{

Magick::Image* image = new Magick::Image();

Value->fillPattern(*image);

delete image;

}

else

{

Value->fillPattern(*value->Value);

}

}

//==============================================================================================

FillRule MagickImage::FillRule::get()

{

return (GraphicsMagick::FillRule)Value->fillRule();

}

//==============================================================================================

void MagickImage::FillRule::set(GraphicsMagick::FillRule value)

{

Value->fillRule((Magick::FillRule)value);

}

//==============================================================================================

FilterType MagickImage::FilterType::get()

{

return (GraphicsMagick::FilterType)Value->filterType();

}

//==============================================================================================

void MagickImage::FilterType::set(GraphicsMagick::FilterType value)

{

Value->filterType((Magick::FilterTypes)value);

}

//==============================================================================================

String^ MagickImage::FlashPixView::get()

{

return Marshaller::Marshal(Value->view());

}

//==============================================================================================

void MagickImage::FlashPixView::set(String^ value)

{

std::string view;

Value->view(Marshaller::Marshal(value, view));

}

//==============================================================================================

String^ MagickImage::Font::get()

{

return Marshaller::Marshal(Value->font());

}

//==============================================================================================

void MagickImage::Font::set(String^ value)

{

std::string font;

Value->font(Marshaller::Marshal(value, font));

}

//==============================================================================================

double MagickImage::FontPointsize::get()

{

return Value->fontPointsize();

}

//==============================================================================================

void MagickImage::FontPointsize::set(double value)

{

Value->fontPointsize(value);

}

//==============================================================================================

MagickFormat MagickImage::Format::get()

{

return EnumHelper::Parse<MagickFormat>(Marshaller::Marshal(Value->magick()), MagickFormat::Unknown);

}

//==============================================================================================

void MagickImage::Format::set(MagickFormat value)

{

if (value == MagickFormat::Unknown)

return;

std::string name;

Marshaller::Marshal(Enum::GetName(MagickFormat::typeid, value), name);

Value->magick(name);

}

//==============================================================================================

MagickFormatInfo^ MagickImage::FormatInfo::get()

{

if (Format == MagickFormat::Unknown)

return nullptr;

for each(MagickFormatInfo^ info in MagickFormatInfo::All)

{

if (info->Format == Format)

return info;

}

return nullptr;

}

//==============================================================================================

GifDisposeMethod MagickImage::GifDisposeMethod::get()

{

return (GraphicsMagick::GifDisposeMethod)Value->gifDisposeMethod();

}

//==============================================================================================

void MagickImage::GifDisposeMethod::set(GraphicsMagick::GifDisposeMethod value)

{

Value->gifDisposeMethod((int)value);

}

//==============================================================================================

bool MagickImage::HasAlpha::get()

{

return Value->matte();

}

//==============================================================================================

void MagickImage::HasAlpha::set(bool value)

{

Value->matte(value);

}

//==============================================================================================

int MagickImage::Height::get()

{

return Convert::ToInt32(Value->size().height());

}

//==============================================================================================

Interlace MagickImage::Interlace::get()

{

return (GraphicsMagick::Interlace)Value->interlaceType();

}

//==============================================================================================

void MagickImage::Interlace::set(GraphicsMagick::Interlace value)

{

Value->interlaceType((Magick::InterlaceType)value);

}

//==============================================================================================

String^ MagickImage::Label::get()

{

std::string label = Value->label();

if (label.length() == 0)

return nullptr;

return Marshaller::Marshal(label);

}

//==============================================================================================

void MagickImage::Label::set(String^ value)

{

if (value == nullptr)

value = "";

std::string label;

Marshaller::Marshal(value, label);

Value->label(label);

}

//==============================================================================================

MagickColor^ MagickImage::MatteColor::get()

{

return gcnew MagickColor(Value->matteColor());

}

//==============================================================================================

void MagickImage::MatteColor::set(MagickColor^ value)

{

const Magick::Color* color = ReferenceEquals(value, nullptr) ? new Magick::Color() : value->CreateColor();

Value->matteColor(*color);

delete color;

}

//==============================================================================================

OrientationType MagickImage::Orientation::get()

{

return (OrientationType)Value->orientation();

}

//==============================================================================================

void MagickImage::Orientation::set(OrientationType value)

{

Value->orientation((Magick::OrientationType)value);

}

//==============================================================================================

MagickGeometry^ MagickImage::Page::get()

{

return gcnew MagickGeometry(Value->page());

}

//==============================================================================================

void MagickImage::Page::set(MagickGeometry^ value)

{

Throw::IfNull("value", value);

const Magick::Geometry* geometry = value->CreateGeometry();

Value->page(*geometry);

delete geometry;

}

//==============================================================================================

int MagickImage::Quality::get()

{

return Convert::ToInt32(Value->quality());

}

//==============================================================================================

void MagickImage::Quality::set(int value)

{

int quality = value < 1 ? 1 : value;

quality = quality > 100 ? 100 : quality;

Value->quality(quality);

}

//==============================================================================================

RenderingIntent MagickImage::RenderingIntent::get()

{

return (GraphicsMagick::RenderingIntent)Value->renderingIntent();

}

//==============================================================================================

void MagickImage::RenderingIntent::set(GraphicsMagick::RenderingIntent value)

{

return Value->renderingIntent((Magick::RenderingIntent)value);

}

//==============================================================================================

Resolution MagickImage::ResolutionUnits::get()

{

return (Resolution)Value->resolutionUnits();

}

//==============================================================================================

void MagickImage::ResolutionUnits::set(Resolution value)

{

return Value->resolutionUnits((Magick::ResolutionType)value);

}

//==============================================================================================

double MagickImage::ResolutionX::get()

{

return Value->xResolution();

}

//==============================================================================================

double MagickImage::ResolutionY::get()

{

return Value->yResolution();

}

//==============================================================================================

String^ MagickImage::Signature::get()

{

try

{

return Marshaller::Marshal(Value->signature(true));

}

catch(Magick::Exception& exception)

{

HandleException(exception);

return nullptr;

}

}

//==============================================================================================

bool MagickImage::StrokeAntiAlias::get()

{

return Value->strokeAntiAlias();

}

//==============================================================================================

void MagickImage::StrokeAntiAlias::set(bool value)

{

Value->strokeAntiAlias(value);

}

//==============================================================================================

MagickColor^ MagickImage::StrokeColor::get()

{

return gcnew MagickColor(Value->strokeColor());

}

//==============================================================================================

void MagickImage::StrokeColor::set(MagickColor^ value)

{

const Magick::Color* color = ReferenceEquals(value, nullptr) ? new Magick::Color() : value->CreateColor();

Value->strokeColor(*color);

delete color;

}

//==============================================================================================

array<double>^ MagickImage::StrokeDashArray::get()

{

const double* strokeDashArray = Value->strokeDashArray();

if (strokeDashArray == NULL)

return nullptr;

return Marshaller::Marshal(strokeDashArray);

}

//==============================================================================================

void MagickImage::StrokeDashArray::set(array<double>^ value)

{

double* strokeDashArray = Marshaller::MarshalAndTerminate(value);

Value->strokeDashArray(strokeDashArray);

delete[] strokeDashArray;

}

//==============================================================================================

double MagickImage::StrokeDashOffset::get()

{

return Value->strokeDashOffset();

}

//==============================================================================================

void MagickImage::StrokeDashOffset::set(double value)

{

Value->strokeDashOffset(value);

}

//==============================================================================================

LineCap MagickImage::StrokeLineCap::get()

{

return (LineCap)Value->strokeLineCap();

}

//==============================================================================================

void MagickImage::StrokeLineCap::set(LineCap value)

{

Value->strokeLineCap((Magick::LineCap)value);

}

//==============================================================================================

LineJoin MagickImage::StrokeLineJoin::get()

{

return (LineJoin)Value->strokeLineJoin();

}

//==============================================================================================

void MagickImage::StrokeLineJoin::set(LineJoin value)

{

Value->strokeLineJoin((Magick::LineJoin)value);

}

//==============================================================================================

int MagickImage::StrokeMiterLimit::get()

{

return Convert::ToInt32(Value->strokeMiterLimit());

}

//==============================================================================================

void MagickImage::StrokeMiterLimit::set(int value)

{

Value->strokeMiterLimit(value);

}

//==============================================================================================

MagickImage^ MagickImage::StrokePattern::get()

{

Magick::Image strokePattern = Value->strokePattern();

if (!strokePattern.isValid())

return nullptr;

return gcnew MagickImage(strokePattern);

}

//==============================================================================================

void MagickImage::StrokePattern::set(MagickImage^ value)

{

if (value == nullptr)

Value->strokePattern(Magick::Image());

else

Value->strokePattern(*value->Value);

}

//==============================================================================================

double MagickImage::StrokeWidth::get()

{

return Value->strokeWidth();

}

//==============================================================================================

void MagickImage::StrokeWidth::set(double value)

{

Value->strokeWidth(value);

}

//==============================================================================================

Encoding^ MagickImage::TextEncoding::get()

{

String^ encoding = Marshaller::Marshal(Value->textEncoding());

if (String::IsNullOrEmpty(encoding))

return nullptr;

try

{

return Encoding::GetEncoding(encoding);

}

catch (ArgumentException^)

{

return nullptr;

}

}

//==============================================================================================

void MagickImage::TextEncoding::set(Encoding^ value)