/// <summary>
        /// 彩度・明度ビューを描画する。
        /// </summary>
        /// <param name="g">Graphicsオブジェクト</param>
        private void PaintSVArea(Graphics g)
        {
            if ((svRenderBuffer == null) && (svArea.Width > 2) && (svArea.Height > 2))
            {
                svRenderBuffer = ImageBuffer.Create(svArea.Width - 2, svArea.Height - 2);
                svDisplayImage = null;
            }

            if ((svDisplayImage == null) && (svRenderBuffer != null))
            {
                // ImageBufferを再レンダリング
                RenderSVImageBuffer();
                svDisplayImage = svRenderBuffer.GetImage();
            }
            if (svDisplayImage != null)
            {
                g.DrawImage(svDisplayImage, svArea.X + 1, svArea.X + 1,
                            svArea.Width - 2, svArea.Height - 2);
            }

            using (Pen pen = new Pen((colorHSV.Value < 0.5f) ? Color.White : Color.Black))
            {
                // 選択されているsaturation, valueの位置に十字カーソルを書く
                int x = svArea.Left + Convert.ToInt32((1.0f - colorHSV.Saturation) * (svArea.Width - 2));
                g.DrawLine(pen, x, svArea.Top, x, svArea.Bottom);
                int y = svArea.Top + Convert.ToInt32((1.0f - colorHSV.Value) * (svArea.Height - 2));
                g.DrawLine(pen, svArea.Left, y, svArea.Right, y);
            }

            using (Pen pen = new Pen(Color.Black))
            {
                g.DrawRectangle(pen, svArea.Left, svArea.Top,
                                svArea.Width - 1, svArea.Height - 1);
            }
        }
        /// <summary>
        /// fileNameで指定されるファイルを読み出し、bufferの指定位置に嵌め込む。
        /// bufferがnullの場合にはアロケートして返す。
        /// </summary>
        /// <param name="fileName">ファイル名</param>
        /// <param name="buffer">バッファ(null指定時はアロケートして返す)</param>
        /// <param name="x">X位置</param>
        /// <param name="y">Y位置</param>
        /// <returns>バッファが返る。</returns>
        private ImageBuffer CombineImage(string fileName, ImageBuffer buffer, int x, int y)
        {
            using (Image image = ReadImage(fileName))
            {
                ImageBuffer srcImage = ImageBuffer.CreateFrom(image);
                if (buffer == null)
                {
                    int width  = srcImage.Width * setting.HorizontalCount;
                    int height = srcImage.Height * setting.VerticalCount;
                    buffer = ImageBuffer.Create(width, height);
                }

                int regionWidth  = buffer.Width / setting.HorizontalCount;
                int regionHeight = buffer.Height / setting.VerticalCount;

                int dstXOffs = regionWidth * x;
                int dstYOffs = regionHeight * y;

                int srcXOffs = (srcImage.Width - regionWidth) / 2;
                int srcYOffs = (srcImage.Height - regionHeight) / 2;

                buffer.WriteImage(srcImage, srcXOffs, srcYOffs, dstXOffs, dstYOffs, regionWidth, regionHeight);
            }

            return(buffer);
        }
Beispiel #3
0
        /// <summary>
        /// 1キャラクターのキャラチップをレンダリングする。
        /// </summary>
        /// <param name="model">レンダリング対象のキャラチップ</param>
        /// <param name="chipSize">キャラチップサイズ</param>
        /// <returns>レンダリングしたImageBufferが返る。</returns>
        private static ImageBuffer RenderCharaChip(Character model, Size chipSize)
        {
            CharaChipRenderData renderData = new CharaChipRenderData();

            model.CopyTo(renderData.Character);

            if (renderData.HasError)
            {
                throw new Exception(Properties.Resources.MessageWriteError);
            }

            ImageBuffer imageBuffer = ImageBuffer.Create(chipSize.Width * 3, chipSize.Height * 4);

            for (int y = 0; y < 4; y++)
            {
                for (int x = 0; x < 3; x++)
                {
                    ImageBuffer buffer = ImageBuffer.Create(chipSize.Width, chipSize.Height);
                    CharaChipRenderer.Draw(renderData, buffer, x, y);
                    imageBuffer.WriteImage(buffer, x * chipSize.Width, y * chipSize.Height);
                }
            }

            return(imageBuffer);
        }
        /// <summary>
        /// 色相領域を描画する。
        /// </summary>
        /// <param name="g"></param>
        private void PaintHueArea(Graphics g)
        {
            if ((hueRenderBuffer == null) && (hueArea.Width > 2) && (hueArea.Height > 2))
            {
                hueRenderBuffer = ImageBuffer.Create(hueArea.Width - 2, hueArea.Height - 2);
                hueDisplayImage = null;
            }

            if ((hueDisplayImage == null) && (hueRenderBuffer != null))
            {
                // ImageBufferを再レンダリング
                RenderHueImageBuffer();
                hueDisplayImage = hueRenderBuffer.GetImage();
            }

            if (hueDisplayImage != null)
            {
                g.DrawImage(hueDisplayImage, hueArea.X + 1, hueArea.Y + 1,
                            hueArea.Width - 2, hueArea.Height - 2);
            }

            using (Pen pen = new Pen(Color.Black))
            {
                // 選択されているHueの位置に十字カーソルを書く
                int x = hueArea.Left + Convert.ToInt32(colorHSV.Hue / 360.0f * (hueArea.Width - 2));
                g.DrawLine(pen, x, hueArea.Top, x, hueArea.Bottom);
            }

            using (Pen pen = new Pen(Color.Black))
            {
                g.DrawRectangle(pen, hueArea.Left, hueArea.Top,
                                hueArea.Width - 1, hueArea.Height - 1);
            }
        }
        public bool Bake(PipelineBakeContext context)
        {
            Console.WriteLine("AnimSet.Bake: " + context.ContentPath);

            var path = context.RawContentDiskPath;

            path += ".txt";
            context.Depend(path);

            //I dont know... I dont know...
            if (!File.Exists(path))
            {
                return(false);
            }

            var img = ImageBuffer.Create(TextureFormat.Color, 64, 64);

            img.Serialize(context.BakedWriter);

            var cellLines = File.ReadAllLines(path);

            context.BakedWriter.Write(cellLines.Length);
            foreach (var line in cellLines)
            {
                context.BakedWriter.Write(line);
            }

            return(true);
        }
        /// <summary>
        /// 処理を行う。
        /// </summary>
        /// <param name="buffer">画像バッファ</param>
        /// <returns>処理結果が返る</returns>
        public override ImageBuffer Process(ImageBuffer buffer)
        {
            ImageBuffer dstImage = ImageBuffer.Create(buffer.Width * 2, buffer.Height * 2);

            // バイキュービックもなにもあったもんじゃない。
            for (int y = 0; y < dstImage.Height; y++)
            {
                for (int x = 0; x < dstImage.Width; x++)
                {
                    dstImage.SetPixel(x, y, buffer.GetPixel((x >> 1), (y >> 1)));
                }
            }

            return(dstImage);
        }
Beispiel #7
0
        /// <summary>
        /// キャラチップデータをエクスポートする
        /// </summary>
        public static void ExportCharaChip(GeneratorSetting setting)
        {
            if (string.IsNullOrEmpty(setting.ExportSetting.ExportFilePath))
            {
                throw new ArgumentException("ExportFilePath not specified.");
            }

            Size charaChipSize = setting.ExportSetting.CharaChipSize;

            int charaPlaneWidth  = charaChipSize.Width * 3;
            int charaPlaneHeight = charaChipSize.Height * 4;

            int exportImageWidth  = charaPlaneWidth * setting.HorizontalCount;
            int exportImageHeight = charaPlaneHeight * setting.VerticalCount;

            ImageBuffer exportBuffer = ImageBuffer.Create(exportImageWidth, exportImageHeight);

            for (int charaY = 0; charaY < setting.VerticalCount; charaY++)
            {
                for (int charaX = 0; charaX < setting.HorizontalCount; charaX++)
                {
                    int index = charaY * setting.HorizontalCount + charaX;
                    if (index >= setting.GetCharacterCount())
                    {
                        continue;
                    }
                    try
                    {
                        Character character = setting.GetCharacter(index);

                        // キャラクターをレンダリングする。
                        ImageBuffer charaChipImage = RenderCharaChip(setting.GetCharacter(charaY * 4 + charaX), charaChipSize);
                        // レンダリングした画像をエクスポートバッファにコピーする。
                        exportBuffer.WriteImage(charaChipImage, charaX * charaPlaneWidth, charaY * charaPlaneHeight);
                    }
                    catch (Exception e)
                    {
                        throw new Exception($"Character{(index + 1)}:{e.Message}");
                    }
                }
            }

            Image image = null;

            image = exportBuffer.GetImage();
            image.Save(setting.ExportSetting.ExportFilePath);
        }
Beispiel #8
0
        /// <summary>
        /// 垂直方向に並べて書き出す。
        /// </summary>
        /// <param name="images">画像</param>
        private void ProcessLineupVertical(ImageBuffer[] images)
        {
            int width  = images.Max((x) => x.Width);  // 水平ピクセル数の最大値
            int height = images.Sum((x) => x.Height); // 垂直ピクセル数の最大値

            ImageBuffer imageBuffer = ImageBuffer.Create(width, height);
            int         yoffs       = 0;

            foreach (ImageBuffer image in images)
            {
                int xoffs = (width - image.Width) / 2;
                imageBuffer.WriteImage(image, xoffs, yoffs);
                yoffs += image.Height;
            }

            WriteOutputImage(imageBuffer);
        }
Beispiel #9
0
        /// <summary>
        /// 画像に処理を行う。
        /// </summary>
        /// <param name="buffer">画像バッファ</param>
        /// <returns>処理結果が返る</returns>
        public override ImageBuffer Process(ImageBuffer buffer)
        {
            System.Drawing.Rectangle clipBounds = setting.ClipBounds;
            ImageBuffer dstImage = ImageBuffer.Create(clipBounds.Width, clipBounds.Height);

            for (int y = 0; y < clipBounds.Height; y++)
            {
                for (int x = 0; x < clipBounds.Width; x++)
                {
                    int srcX = clipBounds.X + x;
                    int srcY = clipBounds.Y + y;

                    dstImage.SetPixel(x, y, buffer.GetPixel(srcX, srcY));
                }
            }

            return(dstImage);
        }
Beispiel #10
0
        /// <summary>
        /// 画像に処理を行う。
        /// </summary>
        /// <param name="src"></param>
        /// <returns></returns>
        public override ImageBuffer Process(ImageBuffer src)
        {
            ImageBuffer dst = ImageBuffer.Create(src.Width, src.Height);

            // 端点を除いてコピー
            for (int y = 0; y < src.Height; y++)
            {
                for (int x = 0; x < src.Width; x++)
                {
                    if (!IsEndPoint(src, x, y))
                    {
                        dst.SetPixel(x, y, dst.GetPixel(x, y));
                    }
                }
            }

            return(dst);
        }
Beispiel #11
0
        /// <summary>
        /// エクスポート処理
        /// </summary>
        private void ExportProc()
        {
            var lastFileName = Properties.Settings.Default.LastExportPath;

            if (System.IO.File.Exists(lastFileName))
            {
                saveFileDialog.InitialDirectory = System.IO.Path.GetDirectoryName(lastFileName);
                saveFileDialog.FileName         = System.IO.Path.GetDirectoryName(lastFileName);
            }
            saveFileDialog.Filter      = Properties.Resources.FILEFILTER_IMAGE;
            saveFileDialog.FilterIndex = 0;
            if (saveFileDialog.ShowDialog(this) != DialogResult.OK)
            {
                return;
            }

            Properties.Settings.Default.LastExportPath = saveFileDialog.FileName;
            var exportFileName = saveFileDialog.FileName;

            // サクッと生成する。
            ImageBuffer imageBuffer = ImageBuffer.Create(faceImageEntrySet.ExportWidth, faceImageEntrySet.ExportHeight);

            for (int i = 0; i < faceImageEntrySet.EntryCount; i++)
            {
                var entry = faceImageEntrySet.GetEntry(i);
                if (!string.IsNullOrEmpty(entry.FileName))
                {
                    using (var srcImage = Image.FromFile(entry.FileName))
                    {
                        var writeImage = ImageBuffer.CreateFrom(srcImage);
                        int dstXOffs   = entry.Width * (i % faceImageEntrySet.HorizontalEntryCount);
                        int dstYOffs   = entry.Height * (i / faceImageEntrySet.HorizontalEntryCount);
                        imageBuffer.WriteImage(writeImage, entry.X, entry.Y, dstXOffs, dstYOffs, entry.Width, entry.Height);
                    }
                }
            }

            using (var image = imageBuffer.GetImage())
            {
                image.Save(exportFileName);
            }
        }
Beispiel #12
0
        /// <summary>
        /// 更新する。
        /// </summary>
        private void UpdateImage()
        {
            int   fillAreaWidth  = (int)(numericUpDownWidth.Value);
            int   fillAreaHeight = (int)(numericUpDownHeight.Value);
            int   outlineWidth   = (int)(numericUpDownOutline.Value);
            Color c      = labelColor.BackColor;
            int   width  = fillAreaWidth + outlineWidth * 2;
            int   height = fillAreaHeight + outlineWidth * 2;

            if ((width > 0) || (height > 0))
            {
                ImageBuffer imageBuffer = ImageBuffer.Create(width, height);
                PaintRoundRect(imageBuffer, outlineWidth, c);
                pictureBox.Image = imageBuffer.GetImage();
            }
            else
            {
                pictureBox.Image = null;
            }
        }
        /// <summary>
        /// 画像に処理を行う。
        /// </summary>
        /// <param name="buffer">画像バッファ</param>
        /// <returns>処理結果が返る</returns>
        public override ImageBuffer Process(ImageBuffer buffer)
        {
            ImageBuffer dstImage = ImageBuffer.Create(buffer.Width * 2, buffer.Height * 2);

            // まずオリジナルと同じにできるところを生成する。
            for (int y = 0; y < dstImage.Height; y += 2)
            {
                for (int x = 0; x < dstImage.Width; x += 2)
                {
                    dstImage.SetPixel(x, y, buffer.GetPixel((x >> 1), (y >> 1)));
                }
            }

            // ここからエンプティなところを埋めてくんだけど。
            // 実は結構面倒だし、タイルになってたらうまくいかんのだよね。ごふっ

            // オリジナルのところの右トナリ
            for (int y = 0; y < dstImage.Height; y += 2)
            {
                for (int x = 1; x < dstImage.Width; x += 2)
                {
                    int   srcX = (x - 1) >> 1;
                    int   srcY = y >> 1;
                    Color src1 = buffer.GetPixel(srcX, srcY);
                    Color src2 = buffer.GetPixel(srcX + 1, srcY);
                    if ((src1.A == 0) || (src2.A == 0))
                    {
                        // どっちか透明なら無色にする。
                    }
                    else
                    {
                        // 両方色ついてるなら混合色を作る
                        Color c = ImageProcessor.Blend(src1, src2);
                        dstImage.SetPixel(x, y, c);
                    }
                }
            }

            // オリジナルのところの1つ下
            for (int y = 1; y < dstImage.Height; y += 2)
            {
                for (int x = 0; x < dstImage.Width; x += 2)
                {
                    int   srcX = x >> 1;
                    int   srcY = (y - 1) >> 1;
                    Color src1 = buffer.GetPixel(srcX, srcY);
                    Color src2 = buffer.GetPixel(srcX, srcY + 1);
                    if ((src1.A == 0) || (src2.A == 0))
                    {
                        // どっちか透明なら無色にする。
                    }
                    else
                    {
                        // 両方色ついてるなら混合色を作る
                        Color c = ImageProcessor.Blend(src1, src2);
                        dstImage.SetPixel(x, y, c);
                    }
                }
            }

            // オリジナルのところの右下
            for (int y = 1; y < dstImage.Height; y += 2)
            {
                for (int x = 1; x < dstImage.Width; x += 2)
                {
                    Color c1 = dstImage.GetPixel(x - 1, y);
                    Color c2 = dstImage.GetPixel(x + 1, y);
                    Color c3 = dstImage.GetPixel(x, y - 1);
                    Color c4 = dstImage.GetPixel(x, y + 1);

                    if (((c1.A != 0) && (c2.A != 0)) || ((c3.A != 0) && (c4.A != 0)))
                    {
                        // 対角のどちらかが色つき
                        // Note:
                        // 斜め対角は右トナリ、左トナリの判定結果が
                        // c1, c2, c3, c4に効き、この判定で処理できる
                        Color c12   = ImageProcessor.Blend(c1, c2);
                        Color c34   = ImageProcessor.Blend(c3, c4);
                        Color c1234 = ImageProcessor.Blend(c12, c34);

                        dstImage.SetPixel(x, y, c1234);
                    }
                }
            }

            return(dstImage);
        }