<> <> <> <<>> <> <<>> DIRECTORY ImageGamuts, CalibratedColor, AIS, SampleCache, IO, FS, ColorPlotGamuts, UserProfileOps, ImagerColor, ImagerColorFns, Rope, CreateCalibration, CalibratedColorFns, Process, PrintColorXForms, ImagerPixel, Real, TRCData; ImageGamutsImpl: CEDAR PROGRAM IMPORTS AIS, SampleCache, UserProfileOps, ColorPlotGamuts, CalibratedColor, CalibratedColorFns, IO, FS,Rope, CreateCalibration, Process, ImagerColorFns, PrintColorXForms, ImagerPixel, Real, TRCData EXPORTS ImageGamuts ~ BEGIN OPEN ImageGamuts; State: TYPE ~ ColorPlotGamuts.State; Projection: TYPE ~ ColorPlotGamuts.Projection; RGBCalibration: TYPE = CalibratedColor.RGBCalibration; SampledCalibration: TYPE = CalibratedColor.SampledCalibration; Sample: TYPE = SampleCache.Sample; Cache: TYPE = SampleCache.Cache; RefCache: TYPE = SampleCache.RefCache; XYZ: TYPE = CalibratedColor.XYZ; CIELAB: TYPE = CalibratedColor.CIELAB; RGB: TYPE = ImagerColor.RGB; ROPE: TYPE = Rope.ROPE; <> <> <> InputData: TYPE = REF InputDataRec; InputDataRec: TYPE = RECORD[rgb: RGB]; <> CreateInputData: PUBLIC PROC [fileStem: ROPE, rgbCal: RGBCalibration] RETURNS [inputData: RefCache] ~ { <> aisFiles: AISFiles _ OpenFiles[fileStem]; nLines: NAT _ aisFiles[r].raster.scanCount; nPixels: NAT _ aisFiles[r].raster.scanLength; white: XYZ _ CalibratedColor.XYZFromRGB[[1,1,1], rgbCal]; ref: REF _ NIL; key: Sample; valid: BOOLEAN _ FALSE; inputData _ SampleCache.CreateRefCache[]; Process.SetPriority[Process.priorityBackground]; FOR line: NAT IN [0..nLines) DO FOR pixel: NAT IN [0..nPixels) DO key.s0 _ AIS.ReadSample[w: aisFiles[r].wRef,line: line, pixel: pixel]; key.s1 _ AIS.ReadSample[w: aisFiles[g].wRef,line: line, pixel: pixel]; key.s2 _ AIS.ReadSample[w: aisFiles[b].wRef,line: line, pixel: pixel]; [valid, ref] _ SampleCache.FetchRef[inputData, key]; IF NOT valid THEN { data: InputData _ NEW[InputDataRec]; data.rgb _ [key.s0/255.0, key.s1/255.0, key.s2/255.0]; SampleCache.StoreRef[inputData, key, data] }; ENDLOOP; ENDLOOP; CloseFiles[aisFiles]; }; OpenFiles: PUBLIC PROC [fileStem: ROPE] RETURNS [aisFiles: AISFiles] ~ { <> aisFiles[r].name _ FindFile[fileStem, "AISseparationKeys.red", "-red"]; aisFiles[g].name _ FindFile[fileStem, "AISseparationKeys.green", "-grn"]; aisFiles[b].name _ FindFile[fileStem, "AISseparationKeys.blue", "-blu"]; FOR c: AISColors IN [r..b] DO aisFiles[c].fRef _ AIS.OpenFile[aisFiles[c].name]; aisFiles[c].wRef _ AIS.OpenWindow[aisFiles[c].fRef]; aisFiles[c].raster _ AIS.ReadRaster[aisFiles[c].fRef] ENDLOOP; }; CloseFiles: PUBLIC PROC [aisFiles: AISFiles] ~ { <> FOR c: AISColors IN [r..b] DO AIS.CloseFile[aisFiles[c].fRef]; ENDLOOP; IF aisFiles[clipped].name#NIL THEN AIS.CloseFile[aisFiles[clipped].fRef]; }; CreateFiles: PUBLIC PROC [fileStem: ROPE, raster: AIS.Raster] RETURNS [aisFiles: AISFiles] ~ { <> aisFiles[r].name _ Rope.Cat[fileStem, "-red.ais"]; aisFiles[g].name _ Rope.Cat[fileStem, "-grn.ais"]; aisFiles[b].name _ Rope.Cat[fileStem, "-blu.ais"]; FOR c: AISColors IN [r..b] DO aisFiles[c].fRef _ AIS.CreateFile[aisFiles[c].name, raster]; aisFiles[c].wRef _ AIS.OpenWindow[aisFiles[c].fRef]; aisFiles[c].raster _ raster; ENDLOOP; aisFiles[clipped].raster _ NEW[AIS.RasterPart _ [ scanCount: raster.scanCount, scanLength: raster.scanLength, scanMode: raster.scanMode, bitsPerPixel: 0, linesPerBlock: -1, paddingPerBlock: 0 ]]; aisFiles[clipped].name _ Rope.Cat[fileStem, "-clipped.ais"]; aisFiles[clipped].fRef _ AIS.CreateFile[aisFiles[clipped].name, aisFiles[clipped].raster]; aisFiles[clipped].wRef _ AIS.OpenWindow[aisFiles[clipped].fRef]; }; FindFile: PUBLIC PROC [stem, key, default: ROPE] RETURNS [ROPE] ~ { fileList: LIST OF ROPE _ UserProfileOps.Expand[ "%g%k|%g|%g|.%k|AISExtensions|AIS|", IO.rope[stem], IO.rope[key], IO.rope[default]]; DO { FileExists: PROCEDURE [fileName:Rope.ROPE] RETURNS [answer:BOOLEAN_TRUE] = { s:IO.STREAM _ FS.StreamOpen[fileName:fileName ! FS.Error => TRUSTED { answer_FALSE; GOTO notThere; }]; IO.Close[s]; EXITS notThere => NULL; }; IF fileList = NIL THEN RETURN [NIL]; IF FileExists[fileList.first] THEN RETURN [fileList.first]; fileList _ fileList.rest }; ENDLOOP; }; <> <> <> <> <> <> <> <> <<};>> <> <> <> <> <<};>> <> <> <> <> <> <> <<[word, ] _ IO.GetTokenRope[stream];>> <> <<[] _ IO.GetChar[stream]; --strip off the :>> <<};>> <> <<[] _ IO.GetToken >> <> <> <> <> <> <> <> <> <> <> <> <> <> <> <<>> <> <<>> <<};>> << >> <> PlotInputData: PUBLIC PROC [state: State, inputData: RefCache, mapData: REF, mapProc: MapProc, imageColorProc: ColorProc _ NIL] ~ { <> plot: PROC[key: Sample, data: REF, hits: INT] = { inputData: InputData _ NARROW[data]; xyz: XYZ _ mapProc[key, inputData.rgb, mapData]; x,y: REAL; rgb: RGB _ imageColorProc[key]; [x,y] _ ColorPlotGamuts.MapValues[state, xyz]; ColorPlotGamuts.MarkPoint[state, Real.Round[x], Real.Round[y], rgb]; }; Process.SetPriority[Process.priorityBackground]; SampleCache.EnumerateRefCache[inputData, plot]; }; GetCalibrations: PUBLIC PROC[rgbAtom, sampledAtom: ATOM] RETURNS[rgbCal: RGBCalibration, sampledCal: SampledCalibration] = { rgbCal _ CreateCalibration.CreateRGB[CreateCalibration.GetRGBDataValues[rgbAtom]]; sampledCal _ CreateCalibration.CreateSampled[CreateCalibration.GetSampledFiles[sampledAtom], sampledAtom]; }; MakeChromaPlot: PUBLIC PROC [pi: PlotInfo, xAxis, yAxis: Projection, mapInfo: MapInfo] ~ { rgbState: State _ ColorPlotGamuts.StateFromRGBCalibration[pi.rgbCal, xAxis, yAxis, pi.res, ColorPlotGamuts.RGBRainbow, pi.rgbCal]; sampledState: State _ ColorPlotGamuts.StateFromCalibration[pi.sampledCal, xAxis, yAxis, pi.res, ColorPlotGamuts.SampledRainbow, pi.sampledCal]; inputData: RefCache _ pi.inputData; IF inputData = NIL THEN { inputData _ CreateInputData[pi.aisRoot, pi.rgbCal]; pi.inputData _ inputData}; ColorPlotGamuts.RGBSampleAndPlot[rgbState, pi.rgbCal, 256, ColorPlotGamuts.HueCircle]; ColorPlotGamuts.SampleAndPlot[sampledState, pi.sampledCal, 256, ColorPlotGamuts.HueCircle]; IF mapInfo.rgbState THEN PlotInputData[rgbState, inputData, mapInfo.mapData, mapInfo.mapProc, Rainbow] ELSE PlotInputData[sampledState, inputData, mapInfo.mapData, mapInfo.mapProc, Rainbow]; ColorPlotGamuts.StatesToInterpress[states: LIST[rgbState, sampledState], ipName: Rope.Cat[pi.ipRoot, ".ip"], label: TRUE, note: pi.note, labelColor: pi.labelColor, bleedBackground: pi.bleedBackground]; }; MakeLStarPlot: PUBLIC PROC [pi: PlotInfo, xAxis: Projection, mapInfo: MapInfo] ~ { rgbState: State _ ColorPlotGamuts.StateFromRGBCalibration[pi.rgbCal, xAxis, lStar, pi.res, ColorPlotGamuts.White, pi.rgbCal]; sampledState: State _ ColorPlotGamuts.StateFromCalibration[pi.sampledCal, xAxis, lStar, pi.res, ColorPlotGamuts.Black, pi.sampledCal]; inputData: RefCache _ pi.inputData; states: LIST OF State _ LIST[sampledState, rgbState]; IF inputData = NIL THEN { inputData _ CreateInputData[pi.aisRoot, pi.rgbCal]; pi.inputData _ inputData}; ColorPlotGamuts.RGBSampleAndPlot[rgbState, pi.rgbCal, 8, ColorPlotGamuts.WholeGamut]; ColorPlotGamuts.SampleAndPlot[sampledState, pi.sampledCal, 16, ColorPlotGamuts.WholeGamut, FALSE]; IF mapInfo.rgbState THEN PlotInputData[rgbState, inputData, mapInfo.mapData, mapInfo.mapProc, SatRainbow] ELSE { PlotInputData[sampledState, inputData, mapInfo.mapData, mapInfo.mapProc, SatRainbow]; states _ LIST[rgbState, sampledState]; }; ColorPlotGamuts.StatesToInterpress[states: states, ipName: Rope.Cat[pi.ipRoot, ".ip"], label: TRUE, note: pi.note, labelColor: pi.labelColor, bleedBackground: pi.bleedBackground]; }; Make3LABViews: PUBLIC PROC [pi: PlotInfo, mapInfo: MapInfo] ~ { ipRoot: ROPE _ pi.ipRoot; pi.ipRoot _ Rope.Cat[ipRoot, "AB"]; MakeChromaPlot[pi: pi, xAxis: aStar, yAxis: bStar, mapInfo: mapInfo]; pi.ipRoot _ Rope.Cat[ipRoot, "AL"]; MakeLStarPlot[pi: pi, xAxis: aStar, mapInfo: mapInfo]; pi.ipRoot _ Rope.Cat[ipRoot, "BL"]; MakeLStarPlot[pi: pi, xAxis: bStar, mapInfo: mapInfo]; }; Rainbow: ColorProc = { RETURN[[R: sample.s0/255.0, G: sample.s1/255.0, B: sample.s2/255.0]]; }; DoSat: PROC[in: RGB] RETURNS[out: RGB] = { hsl: ImagerColorFns.HSL_ ImagerColorFns.HSLFromRGB[boundRGB[in]]; boundRGB: PROC[val: RGB] RETURNS[RGB] = { RETURN[[R: MAX[MIN[val.R, 1],0], G: MAX[MIN[val.G, 1],0], B: MAX[MIN[val.B, 1],0]]]}; out _ ImagerColorFns.RGBFromHSL[[H: hsl.H, S: hsl.S, L: 0.5]]; }; SatRainbow: ColorProc = { rgb: RGB _ [R: sample.s0/255.0, G: sample.s1/255.0, B: sample.s2/255.0]; rgb _ DoSat[rgb]; RETURN[rgb]; }; SatRGB: ColorPlotGamuts.GetColorProc = { --assumes data is RGBCalibration cal: RGBCalibration _ NARROW[data]; rgb: RGB _ CalibratedColor.RGBFromXYZ[xyz, cal]; rgb _ DoSat[rgb]; RETURN[rgb]; }; SatSampled: ColorPlotGamuts.GetColorProc = { --assumes data is RGBCalibration cal: SampledCalibration _ NARROW[data]; triple: CalibratedColor.Triple _ CalibratedColor.TripleFromXYZ[xyz, cal].triple; rgb: RGB _ [triple.v0, triple.v1, triple.v2]; rgb _ DoSat[rgb]; RETURN[rgb]; }; <> <> <> <> <> GetPlotInfo: PUBLIC PROC [aisRoot, ipRoot, note: ROPE, res: NAT, rgbCal: RGBCalibration, sampledCal: SampledCalibration, labelColor: ImagerColor.Color, bleedBackground: BOOLEAN] RETURNS[PlotInfo] = { RETURN[[aisRoot: aisRoot, ipRoot: ipRoot, note: note, res: res, rgbCal: rgbCal, sampledCal: sampledCal, labelColor: labelColor, bleedBackground: bleedBackground]]; }; GetMonitorMapInfo: PUBLIC PROC [rgbCal: RGBCalibration] RETURNS[MapInfo] = { RETURN[[mapProc: RGBMap, mapData: rgbCal, rgbState: TRUE]]; }; GetMappedMapInfo: PUBLIC PROC [tables: PrintColorXForms.MatrixTables, rgbCal: RGBCalibration] RETURNS[MapInfo] = { data: MatrixMapData _ NEW[MatrixMapDataRec _ [ tables: tables, rgbCal: rgbCal ]]; RETURN[[mapProc: MatrixMap, mapData: data, rgbState: TRUE]]; }; GetPrinterMapInfo: PUBLIC PROC [tables: PrintColorXForms.MatrixTables, sampledCal: SampledCalibration] RETURNS[MapInfo] = { data: PrinterMapData _ NEW[PrinterMapDataRec _ [ tables: tables, sampledCal: sampledCal ]]; RETURN[[mapProc: PrinterMap, mapData: data, rgbState: FALSE]]; }; RGBMap: PUBLIC MapProc = { rgbCal: RGBCalibration _ NARROW[data]; xyz: XYZ _ CalibratedColor.XYZFromRGB[rgb, rgbCal]; RETURN[xyz]; }; MatrixMap: PUBLIC MapProc = { mmData: MatrixMapData _ NARROW[data]; mapped: Sample _ MatrixMapProc[rgbBytes, mmData.tables]; xyz: XYZ _ CalibratedColor.XYZFromRGB[[R: mapped.s0/255.0, G: mapped.s1/255.0, B: mapped.s2/255.0], mmData.rgbCal]; RETURN[xyz]; }; PrinterMap: PUBLIC MapProc = { pmData: PrinterMapData _ NARROW[data]; mapped: Sample _ MatrixMapProc[rgbBytes, pmData.tables]; xyz: XYZ _ CalibratedColor.XYZFromTriple[ [v0: mapped.s0/255.0, v1: mapped.s1/255.0, v2: mapped.s2/255.0], pmData.sampledCal]; RETURN[xyz]; }; <