/// <summary> /// Changes the rendering intent of the color profile to the specified <see cref="RenderingIntent" /> and saves the profile to a new file. /// </summary> /// <param name="profilePath">The path of the color profile.</param> /// <param name="renderingIntent">The rendering intent to use for the color profile.</param> /// <param name="newProfileFileName">The path of the color profile with the new rendering intent.</param> /// <returns><c>true</c> if the rendering intent was changed; otherwise, <c>false</c>.</returns> /// <exception cref="LCMSException"> /// The color profile could not be opened. /// -or- /// An error occurred saving the profile with the new rendering intent. /// </exception> internal static bool ChangeProfileRenderingIntent(string profilePath, RenderingIntent renderingIntent, out string newProfileFileName) { newProfileFileName = null; bool renderingIntentChanged = false; using (LCMSProfileHandle profile = LCMSHelper.OpenColorProfile(profilePath)) { if (profile.IsInvalid) { throw new LCMSException(Resources.OpenDestiniationProfileError); } RenderingIntent profileRenderingIntent = LCMSHelper.GetProfileRenderingIntent(profile); if (profileRenderingIntent != renderingIntent) { LCMSHelper.SetProfileRenderingIntent(profile, renderingIntent); newProfileFileName = Path.Combine(Path.GetTempPath(), Path.GetRandomFileName()); if (!LCMSHelper.SaveColorProfile(profile, newProfileFileName)) { throw new LCMSException(Resources.ChangeRenderingIntentError); } renderingIntentChanged = true; } } return(renderingIntentChanged); }
internal static LCMSEnums.ConvertProfileStatus ConvertToProfile( LCMSProfileHandle inputProfile, LCMSProfileHandle outputProfile, RenderingIntent renderingIntent, LCMSEnums.TransformFlags flags, ref LCMSStructs.BitmapData input, ref LCMSStructs.BitmapData output ) { if (IntPtr.Size == 8) { return(LCMS_64.ConvertToProfile( inputProfile, outputProfile, renderingIntent, flags, ref input, ref output )); } else { return(LCMS_86.ConvertToProfile( inputProfile, outputProfile, renderingIntent, flags, ref input, ref output )); } }
/// <summary> /// Create a new <see cref="InlineImage"/>. /// </summary> internal InlineImage(PdfRectangle bounds, int widthInSamples, int heightInSamples, int bitsPerComponent, bool isImageMask, RenderingIntent renderingIntent, bool interpolate, ColorSpace?colorSpace, IReadOnlyList <decimal> decode, IReadOnlyList <byte> bytes, IReadOnlyList <IFilter> filters, DictionaryToken streamDictionary) { Bounds = bounds; WidthInSamples = widthInSamples; HeightInSamples = heightInSamples; ColorSpace = colorSpace; Decode = decode; BitsPerComponent = bitsPerComponent; IsImageMask = isImageMask; RenderingIntent = renderingIntent; Interpolate = interpolate; RawBytes = bytes; bytesFactory = new Lazy <IReadOnlyList <byte> >(() => { var b = bytes.ToArray(); for (var i = 0; i < filters.Count; i++) { var filter = filters[i]; b = filter.Decode(b, streamDictionary, i); } return(b); }); }
internal static bool UseBlackPointCompensation(bool blackPointCompensation, RenderingIntent intent) { // Black point compensation should not be used when rendering in Absolute Colorimetric according to // https://www.adobe.com/content/dam/Adobe/en/devnet/photoshop/sdk/AdobeBPC.pdf return(blackPointCompensation && intent != RenderingIntent.AbsoluteColorimetric); }
/// <summary> /// Creates a new <see cref="XObjectImage"/>. /// </summary> internal XObjectImage(PdfRectangle bounds, int widthInSamples, int heightInSamples, int bitsPerComponent, ColorSpace?colorSpace, bool isJpxEncoded, bool isImageMask, RenderingIntent renderingIntent, bool interpolate, IReadOnlyList <decimal> decode, DictionaryToken imageDictionary, IReadOnlyList <byte> rawBytes, Lazy <IReadOnlyList <byte> > bytes) { Bounds = bounds; WidthInSamples = widthInSamples; HeightInSamples = heightInSamples; BitsPerComponent = bitsPerComponent; ColorSpace = colorSpace; IsJpxEncoded = isJpxEncoded; IsImageMask = isImageMask; RenderingIntent = renderingIntent; Interpolate = interpolate; Decode = decode; ImageDictionary = imageDictionary ?? throw new ArgumentNullException(nameof(imageDictionary)); RawBytes = rawBytes; bytesFactory = bytes; }
internal static extern LCMSTransformHandleX64 CreateProofingTransformBGRA8( LCMSProfileHandle input, LCMSProfileHandle display, RenderingIntent displayIntent, LCMSProfileHandle proofing, RenderingIntent proofingIntent, LCMSEnums.TransformFlags flags );
internal static extern LCMSEnums.ConvertProfileStatus ConvertToProfile( LCMSProfileHandle inputProfile, LCMSProfileHandle outputProfile, RenderingIntent renderingIntent, LCMSEnums.TransformFlags flags, [In()] ref LCMSStructs.BitmapData input, [In()] ref LCMSStructs.BitmapData output );
public XObjectContentRecord(XObjectType type, StreamToken stream, TransformationMatrix appliedTransformation, RenderingIntent defaultRenderingIntent) { Type = type; Stream = stream ?? throw new ArgumentNullException(nameof(stream)); AppliedTransformation = appliedTransformation; DefaultRenderingIntent = defaultRenderingIntent; }
/// <summary> /// Converts the PCS color into the device color /// </summary> /// <param name="Profile">The profile that will be used for the conversion</param> /// <param name="pcs">The PCS color (has to match the profiles PCS color type)</param> /// <param name="PrefRenderingIntent">The preferred rendering intent</param> /// <returns>The converted color in the device color type</returns> public Color ToDevice(ICC Profile, Color pcs, RenderingIntent PrefRenderingIntent) { InValues = pcs.ColorArray; InModel = pcs.Model; this.Profile = Profile; PreferredRenderingIntent = PrefRenderingIntent; IsDefault = true; return Do_PCS(); }
/// <summary> /// Converts the device color into the PCS color /// </summary> /// <param name="Profile">The profile that will be used for the conversion</param> /// <param name="inColor">The device color (has to match the profiles device color type)</param> /// <param name="PrefRenderingIntent">The preferred rendering intent</param> /// <returns>The converted color in the PCS color type</returns> public Color ToPCS(ICC Profile, Color inColor, RenderingIntent PrefRenderingIntent) { InValues = inColor.ColorArray; InModel = inColor.Model; this.Profile = Profile; PreferredRenderingIntent = PrefRenderingIntent; IsDefault = true; return(Do_Device()); }
/// <summary> /// Converts the PCS color into the device color /// </summary> /// <param name="Profile">The profile that will be used for the conversion</param> /// <param name="pcs">The PCS color (has to match the profiles PCS color type)</param> /// <param name="PrefRenderingIntent">The preferred rendering intent</param> /// <returns>The converted color in the device color type</returns> public Color ToDevice(ICC Profile, Color pcs, RenderingIntent PrefRenderingIntent) { InValues = pcs.ColorArray; InModel = pcs.Model; this.Profile = Profile; PreferredRenderingIntent = PrefRenderingIntent; IsDefault = true; return(Do_PCS()); }
internal static void SetProfileRenderingIntent(LCMSProfileHandle hProfile, RenderingIntent newRenderingIntent) { if (IntPtr.Size == 8) { LCMS_64.SetProfileRenderingIntent(hProfile, newRenderingIntent); } else { LCMS_86.SetProfileRenderingIntent(hProfile, newRenderingIntent); } }
/// <summary> /// Converts the PCS color into the device color /// </summary> /// <param name="Profile">The profile that will be used for the conversion</param> /// <param name="pcs">The PCS color (has to match the profiles PCS color type)</param> /// <param name="PrefRenderingIntent">The preferred rendering intent</param> /// <param name="ConversionMethod">The method of conversion</param> /// <param name="ConversionType">The type of conversion</param> /// <returns>The converted color in the device color type</returns> public Color ToDevice(ICC Profile, Color pcs, RenderingIntent PrefRenderingIntent, ICCconversionMethod ConversionMethod, ICCconversionType ConversionType) { InValues = pcs.ColorArray; InModel = pcs.Model; this.Profile = Profile; PreferredRenderingIntent = PrefRenderingIntent; this.ConversionMethod = ConversionMethod; this.ConversionType = ConversionType; IsDefault = false; return(Do_PCS()); }
/// <summary> /// Converts the device color into the PCS color /// </summary> /// <param name="Profile">The profile that will be used for the conversion</param> /// <param name="inColor">The device color (has to match the profiles device color type)</param> /// <param name="ConversionMethod">The method of conversion</param> /// <param name="ConversionType">The type of conversion</param> /// <returns>The converted color in the PCS color type</returns> public Color ToPCS(ICC Profile, Color inColor, ICCconversionMethod ConversionMethod, ICCconversionType ConversionType) { InValues = inColor.ColorArray; InModel = inColor.Model; this.Profile = Profile; PreferredRenderingIntent = ColorConverter.PreferredRenderingIntent; this.ConversionMethod = ConversionMethod; this.ConversionType = ConversionType; IsDefault = false; return(Do_Device()); }
internal static LCMSTransformHandle CreateProofingTransformBGRA8( LCMSProfileHandle input, LCMSProfileHandle display, RenderingIntent displayIntent, LCMSProfileHandle proofing, RenderingIntent proofingIntent, bool checkGamut, Color gamutWarningColor, bool blackPointCompensation ) { LCMSEnums.TransformFlags flags = LCMSEnums.TransformFlags.None; if (checkGamut) { flags |= LCMSEnums.TransformFlags.GamutCheck; SetGamutWarningColor(gamutWarningColor); } else { flags |= LCMSEnums.TransformFlags.SoftProofing; } if (UseBlackPointCompensation(blackPointCompensation, proofingIntent)) { flags |= LCMSEnums.TransformFlags.BlackPointCompensation; } if (IntPtr.Size == 8) { return(LCMS_64.CreateProofingTransformBGRA8( input, display, displayIntent, proofing, proofingIntent, flags )); } else { return(LCMS_86.CreateProofingTransformBGRA8( input, display, displayIntent, proofing, proofingIntent, flags )); } }
/// <summary> /// Create a new <see cref="InlineImage"/>. /// </summary> internal InlineImage(PdfRectangle bounds, int widthInSamples, int heightInSamples, int bitsPerComponent, bool isImageMask, RenderingIntent renderingIntent, bool interpolate, ColorSpace?colorSpace, IReadOnlyList <decimal> decode, IReadOnlyList <byte> bytes, IReadOnlyList <IFilter> filters, DictionaryToken streamDictionary, ColorSpaceDetails colorSpaceDetails) { Bounds = bounds; WidthInSamples = widthInSamples; HeightInSamples = heightInSamples; ColorSpace = colorSpace; Decode = decode; BitsPerComponent = bitsPerComponent; IsImageMask = isImageMask; RenderingIntent = renderingIntent; Interpolate = interpolate; ImageDictionary = streamDictionary; RawBytes = bytes; ColorSpaceDetails = colorSpaceDetails; var supportsFilters = true; foreach (var filter in filters) { if (!filter.IsSupported) { supportsFilters = false; break; } } bytesFactory = supportsFilters ? new Lazy <IReadOnlyList <byte> >(() => { var b = bytes.ToArray(); for (var i = 0; i < filters.Count; i++) { var filter = filters[i]; b = filter.Decode(b, streamDictionary, i); } return(b); }) : null; }
public SoftProofingConfigToken( ColorProfileInfo inputProfile, ColorProfileInfo monitorProfile, RenderingIntent displayIntent, ColorProfileInfoCollection proofingProfiles, int proofingProfileIndex, RenderingIntent proofingIntent, bool showGamutWarning, Color gamutWarningColor, bool blackPointCompensation ) { this.InputColorProfile = inputProfile; this.DisplayColorProfile = monitorProfile; this.DisplayIntent = displayIntent; this.ProofingColorProfiles = proofingProfiles; this.ProofingProfileIndex = proofingProfileIndex; this.ProofingIntent = proofingIntent; this.ShowGamutWarning = showGamutWarning; this.GamutWarningColor = gamutWarningColor; this.BlackPointCompensation = blackPointCompensation; }
/// <summary> /// Converts a color to the ICC color /// </summary> /// <param name="InColor">The color to convert</param> /// <param name="profile">The icc file to be used for the conversion</param> /// <param name="ConversionType">The type of conversion</param> /// <param name="ConversionMethod">The method of conversion</param> /// <param name="PrefRenderingIntent">The preferred rendering intent</param> /// <returns>The converted color</returns> public Color ToICC(Color InColor, ICC profile, RenderingIntent PrefRenderingIntent, ICCconversionType ConversionType, ICCconversionMethod ConversionMethod) { if (ICC_Converter.IsSameSpace(InColor.Model, profile.Header.DataColorspace)) { return ICCconverter.ToPCS(profile, InColor, PrefRenderingIntent, ConversionMethod, ConversionType); } else if (ICC_Converter.IsSameSpace(InColor.Model, profile.Header.PCS)) { return ICCconverter.ToDevice(profile, InColor, PrefRenderingIntent, ConversionMethod, ConversionType); } else { return ToICC(ToICC_PCS(InColor, profile), profile, PrefRenderingIntent, ConversionType, ConversionMethod); } }
internal static extern void SetProfileRenderingIntent(LCMSProfileHandle hProfile, RenderingIntent intent);
public sRGBChunk(PNGImage image) : base("sRGB", image) { _ri = RenderingIntent.Perceptual; }
private bool SaveImage() { bool result = false; ColorProfileInfo profile = this.proofingProfileIndex >= 0 ? this.proofingColorProfiles[this.proofingProfileIndex] : this.inputProfile; if (CanSaveInColorSpace(profile.ColorSpace)) { try { if (this.saveFileDialog1.ShowDialog(this) == DialogResult.OK) { bool tiff = SaveFormatIsTIFF(this.saveFileDialog1.FileName); using (SaveOptionsDialog optionsDialog = new SaveOptionsDialog(tiff, profile)) { optionsDialog.BackColor = BackColor; optionsDialog.ForeColor = ForeColor; if (optionsDialog.ShowDialog(this) == DialogResult.OK) { SaveOptions options = optionsDialog.Options; BitmapSource source = null; Uri destinationProfileUri = null; if (profile.Equals(this.inputProfile)) { // No conversion is necessary when saving as the input color profile. source = GetBitmapSourceFromEffectSourceSurface(tiff, options); destinationProfileUri = new Uri(this.inputProfile.Path, UriKind.Absolute); } else { // Convert the image to the destination color profile. PixelFormat destinationPixelFormat = GetDestiniationPixelFormat(tiff, profile.ColorSpace); WriteableBitmap writable = new WriteableBitmap( this.EffectSourceSurface.Width, this.EffectSourceSurface.Height, options.HorizontalResolution, options.VerticalResolution, destinationPixelFormat, null ); RenderingIntent destinationRenderingIntent = (RenderingIntent)this.proofingIntentCombo.SelectedIndex; ColorProfileHelper.ConvertToColorProfile( this.inputProfile.Path, profile.Path, destinationRenderingIntent, this.blackPointCheckBox.Checked, this.EffectSourceSurface, writable ); source = writable; // Write a new profile with the selected rendering intent, if necessary. if (ColorProfileHelper.ChangeProfileRenderingIntent(profile.Path, destinationRenderingIntent, out this.destinationProfileTempPath)) { destinationProfileUri = new Uri(this.destinationProfileTempPath, UriKind.Absolute); } else { destinationProfileUri = new Uri(profile.Path, UriKind.Absolute); } } BitmapEncoder encoder; if (tiff) { TIFFSaveOptions tiffOptions = (TIFFSaveOptions)options; encoder = new TiffBitmapEncoder() { Compression = tiffOptions.LZWCompression ? TiffCompressOption.Lzw : TiffCompressOption.None }; } else { JPEGSaveOptions jpegOptions = (JPEGSaveOptions)options; encoder = new JpegBitmapEncoder() { QualityLevel = jpegOptions.Quality, }; } ColorContext[] colorContexts = new ColorContext[] { new ColorContext(destinationProfileUri) }; encoder.Frames.Add(BitmapFrame.Create(source, null, null, Array.AsReadOnly(colorContexts))); using (FileStream stream = new FileStream(this.saveFileDialog1.FileName, FileMode.Create, FileAccess.Write, FileShare.None)) { encoder.Save(stream); } result = true; } } } } catch (IOException ex) { ShowErrorMessage(ex.Message); } catch (LCMSException ex) { ShowErrorMessage(ex.Message); } catch (OverflowException ex) { ShowErrorMessage(ex.Message); } catch (UnauthorizedAccessException ex) { ShowErrorMessage(ex.Message); } } return(result); }
/// <summary> /// Converts the image to the specified output color profile. /// </summary> /// <param name="inputProfilePath">The path of the input color profile.</param> /// <param name="outputProfilePath">The path of the output color profile.</param> /// <param name="intent">The rendering intent to use for the conversion.</param> /// <param name="blackPointCompensation"><c>true</c> if black point compensation should be used; otherwise, <c>false</c>.</param> /// <param name="source">The source image to convert.</param> /// <param name="destination">The destination image to place the converted pixels.</param> /// <exception cref="LCMSException"> /// The input profile could not be opened. /// -or- /// The output profile could not be opened. /// -or- /// The color transform could not be created. /// -or- /// The source and destination images are not the same size. /// </exception> internal static void ConvertToColorProfile( string inputProfilePath, string outputProfilePath, RenderingIntent intent, bool blackPointCompensation, Surface source, WriteableBitmap destination ) { using (LCMSProfileHandle inputProfile = LCMSHelper.OpenColorProfile(inputProfilePath)) { if (inputProfile.IsInvalid) { throw new LCMSException(Resources.OpenSourceProfileError); } using (LCMSProfileHandle outputProfile = LCMSHelper.OpenColorProfile(outputProfilePath)) { if (outputProfile.IsInvalid) { throw new LCMSException(Resources.OpenDestiniationProfileError); } LCMSStructs.BitmapData sourceBitmapData = new LCMSStructs.BitmapData { width = (uint)source.Width, height = (uint)source.Height, format = LCMSEnums.BitmapFormat.Bgra8, stride = (uint)source.Stride, scan0 = source.Scan0.Pointer }; LCMSStructs.BitmapData destinationBitmapData = new LCMSStructs.BitmapData { width = (uint)destination.PixelWidth, height = (uint)destination.PixelHeight, format = BitmapFormatFromWICPixelFormat(destination.Format), stride = (uint)destination.BackBufferStride, scan0 = destination.BackBuffer }; LCMSEnums.TransformFlags flags = LCMSEnums.TransformFlags.None; if (LCMSHelper.UseBlackPointCompensation(blackPointCompensation, intent)) { flags |= LCMSEnums.TransformFlags.BlackPointCompensation; } LCMSEnums.ConvertProfileStatus status = LCMSHelper.ConvertToProfile( inputProfile, outputProfile, intent, flags, ref sourceBitmapData, ref destinationBitmapData ); if (status != LCMSEnums.ConvertProfileStatus.Ok) { switch (status) { case LCMSEnums.ConvertProfileStatus.InvalidParameter: throw new LCMSException(Resources.ConvertProfileInvalidParameter); case LCMSEnums.ConvertProfileStatus.DifferentImageDimensions: throw new LCMSException(Resources.DifferentImageDimensions); case LCMSEnums.ConvertProfileStatus.CreateTransformFailed: throw new LCMSException(Resources.CreateTransformError); default: break; } } } } }
/// <summary> /// Converts the device color into the PCS color /// </summary> /// <param name="Profile">The profile that will be used for the conversion</param> /// <param name="inColor">The device color (has to match the profiles device color type)</param> /// <param name="PrefRenderingIntent">The preferred rendering intent</param> /// <param name="ConversionMethod">The method of conversion</param> /// <param name="ConversionType">The type of conversion</param> /// <returns>The converted color in the PCS color type</returns> public Color ToPCS(ICC Profile, Color inColor, RenderingIntent PrefRenderingIntent, ICCconversionMethod ConversionMethod, ICCconversionType ConversionType) { InValues = inColor.ColorArray; InModel = inColor.Model; this.Profile = Profile; PreferredRenderingIntent = PrefRenderingIntent; this.ConversionMethod = ConversionMethod; this.ConversionType = ConversionType; IsDefault = false; return Do_Device(); }
/// <summary> /// Converts the device color into the PCS color /// </summary> /// <param name="Profile">The profile that will be used for the conversion</param> /// <param name="inColor">The device color (has to match the profiles device color type)</param> /// <param name="PrefRenderingIntent">The preferred rendering intent</param> /// <returns>The converted color in the PCS color type</returns> public Color ToPCS(ICC Profile, Color inColor, RenderingIntent PrefRenderingIntent) { InValues = inColor.ColorArray; InModel = inColor.Model; this.Profile = Profile; PreferredRenderingIntent = PrefRenderingIntent; IsDefault = true; return Do_Device(); }
public InlineImage CreateInlineImage(TransformationMatrix transformationMatrix, IFilterProvider filterProvider, IPdfTokenScanner tokenScanner, RenderingIntent defaultRenderingIntent, IResourceStore resourceStore) { if (Properties == null || Bytes == null) { throw new InvalidOperationException($"Inline image builder not completely defined before calling {nameof(CreateInlineImage)}."); } bool TryMapColorSpace(NameToken name, out ColorSpace colorSpaceResult) { if (name.TryMapToColorSpace(out colorSpaceResult)) { return(true); } if (TryExtendedColorSpaceNameMapping(name, out colorSpaceResult)) { return(true); } if (!resourceStore.TryGetNamedColorSpace(name, out var colorSpaceNamedToken)) { return(false); } if (colorSpaceNamedToken.Name.TryMapToColorSpace(out colorSpaceResult)) { return(true); } if (TryExtendedColorSpaceNameMapping(colorSpaceNamedToken.Name, out colorSpaceResult)) { return(true); } return(false); } var bounds = transformationMatrix.Transform(new PdfRectangle(new PdfPoint(1, 1), new PdfPoint(0, 0))); var width = GetByKeys <NumericToken>(NameToken.Width, NameToken.W, true).Int; var height = GetByKeys <NumericToken>(NameToken.Height, NameToken.H, true).Int; var maskToken = GetByKeys <BooleanToken>(NameToken.ImageMask, NameToken.Im, false); var isMask = maskToken?.Data == true; var bitsPerComponent = GetByKeys <NumericToken>(NameToken.BitsPerComponent, NameToken.Bpc, !isMask)?.Int ?? 1; var colorSpace = default(ColorSpace?); if (!isMask) { var colorSpaceName = GetByKeys <NameToken>(NameToken.ColorSpace, NameToken.Cs, false); if (colorSpaceName == null) { var colorSpaceArray = GetByKeys <ArrayToken>(NameToken.ColorSpace, NameToken.Cs, true); if (colorSpaceArray.Length == 0) { throw new PdfDocumentFormatException("Empty ColorSpace array defined for inline image."); } if (!(colorSpaceArray.Data[0] is NameToken firstColorSpaceName)) { throw new PdfDocumentFormatException($"Invalid ColorSpace array defined for inline image: {colorSpaceArray}."); } if (!TryMapColorSpace(firstColorSpaceName, out var colorSpaceMapped)) { throw new PdfDocumentFormatException($"Invalid ColorSpace defined for inline image: {firstColorSpaceName}."); } colorSpace = colorSpaceMapped; } else { if (!TryMapColorSpace(colorSpaceName, out var colorSpaceMapped)) { throw new PdfDocumentFormatException($"Invalid ColorSpace defined for inline image: {colorSpaceName}."); } colorSpace = colorSpaceMapped; } } var renderingIntent = GetByKeys <NameToken>(NameToken.Intent, null, false)?.Data?.ToRenderingIntent() ?? defaultRenderingIntent; var filterNames = new List <NameToken>(); var filterName = GetByKeys <NameToken>(NameToken.Filter, NameToken.F, false); if (filterName == null) { var filterArray = GetByKeys <ArrayToken>(NameToken.Filter, NameToken.F, false); if (filterArray != null) { filterNames.AddRange(filterArray.Data.OfType <NameToken>()); } } else { filterNames.Add(filterName); } var filters = filterProvider.GetNamedFilters(filterNames); var decodeRaw = GetByKeys <ArrayToken>(NameToken.Decode, NameToken.D, false) ?? new ArrayToken(EmptyArray <IToken> .Instance); var decode = decodeRaw.Data.OfType <NumericToken>().Select(x => x.Data).ToArray(); var filterDictionaryEntries = new Dictionary <NameToken, IToken>(); var decodeParamsDict = GetByKeys <DictionaryToken>(NameToken.DecodeParms, NameToken.Dp, false); if (decodeParamsDict == null) { var decodeParamsArray = GetByKeys <ArrayToken>(NameToken.DecodeParms, NameToken.Dp, false); if (decodeParamsArray != null) { filterDictionaryEntries[NameToken.DecodeParms] = decodeParamsArray; } } else { filterDictionaryEntries[NameToken.DecodeParms] = decodeParamsDict; } var streamDictionary = new DictionaryToken(filterDictionaryEntries); var interpolate = GetByKeys <BooleanToken>(NameToken.Interpolate, NameToken.I, false)?.Data ?? false; return(new InlineImage(bounds, width, height, bitsPerComponent, isMask, renderingIntent, interpolate, colorSpace, decode, Bytes, filters, streamDictionary)); }
/// <summary> /// Converts the PCS color into the device color /// </summary> /// <param name="Profile">The profile that will be used for the conversion</param> /// <param name="pcs">The PCS color (has to match the profiles PCS color type)</param> /// <param name="ConversionMethod">The method of conversion</param> /// <param name="ConversionType">The type of conversion</param> /// <returns>The converted color in the device color type</returns> public Color ToDevice(ICC Profile, Color pcs, ICCconversionMethod ConversionMethod, ICCconversionType ConversionType) { InValues = pcs.ColorArray; InModel = pcs.Model; this.Profile = Profile; PreferredRenderingIntent = ColorConverter.PreferredRenderingIntent; this.ConversionMethod = ConversionMethod; this.ConversionType = ConversionType; IsDefault = false; return Do_PCS(); }