//이미지 가져오기( + .psd)
private byte[] OpenImage()
{
FileDialog.ShowDialog();
if (FileDialog.FileNames.Length > 0)
{
string[] tokens = regex.Split(FileDialog.SafeFileName);
foreach (string fileName in FileDialog.FileNames)
{
if (tokens[1].ToLower().Equals("psd"))
{
PsdFile.Load(fileName);
using (Process = new MemoryStream())
{
using (var imageFactory = new ImageFactory(preserveExifData: true))
{
Bitmap bitmap = ImageDecoder.DecodeImage(PsdFile);
imageFactory.Load(bitmap)
.Save(Process);
}
return(Process.ToArray());
}
}
else
{
return(File.ReadAllBytes(fileName));
}
}
}
return(null);
}
private void button1_Click(object sender, EventArgs e)
{
OpenFileDialog dlg = new OpenFileDialog();
dlg.Filter = "Photoshop Files(*.psd)|*.psd";
if (dlg.ShowDialog() == DialogResult.OK)
{
m_File = new PsdFile();
m_File.Load(dlg.FileName);
txtLoadPath.Text = dlg.FileName;
foreach (Layer L in m_File.Layers)
{
lstLayers.Items.Add(L.Name);
}
Image img = m_File.CompositImage;
picLayerImage.Image = img;
picLayerImage.Refresh();
MessageBox.Show("Layer count : " + m_File.Layers.Count);
MessageBox.Show("ImageResource count : " + m_File.ImageResources.Count);
MessageBox.Show("ImageData count : " + m_File.ImageData.Length);
MessageBox.Show("Rows : " + m_File.Rows);
MessageBox.Show("WidthUnit : " + m_File.Resolution.WidthUnit + "\n" + "HeightUnit : " + m_File.Resolution.HeightUnit);
MessageBox.Show("Depth : " + m_File.Depth);
//m_File.Load("")
}
}
public Bitmap Render(Stream s, out IList <IPsdLayer> layers, out Size size, ShowLayerDelegate showLayerCallback, ComposeLayerDelegate composeLayer)
{
PsdFile file = new PsdFile();
file.Load(s);
//Start with a transparent bitmap (not all PSD files have background layers)
size = new Size(file.Columns, file.Rows);
Bitmap b = new Bitmap(file.Columns, file.Rows);
//ImageDecoder.DecodeImage(file.Layers[0]); //Layers collection doesn't include the composed layer
Graphics g = Graphics.FromImage(b);
using (g){
g.CompositingQuality = System.Drawing.Drawing2D.CompositingQuality.HighQuality;
g.CompositingMode = System.Drawing.Drawing2D.CompositingMode.SourceOver;
g.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.HighQuality;
g.PixelOffsetMode = System.Drawing.Drawing2D.PixelOffsetMode.HighQuality;
g.InterpolationMode = System.Drawing.Drawing2D.InterpolationMode.HighQualityBicubic;
for (int i = 0; i < file.Layers.Count; i++)
{
if (showLayerCallback(i, file.Layers[i].Name, file.Layers[i].Visible))
{
using (Bitmap frame = ImageDecoder.DecodeImage(file.Layers[i])){
composeLayer(g, frame, file.Layers[i]);
}
}
}
}
layers = getLayers(file);
return(b);
}
public IList <IPsdLayer> GetLayers(Stream s)
{
PsdFile file = new PsdFile();
file.Load(s);
return(getLayers(file));
}
public static ImageC FromStream(Stream stream)
{
long PreviousPosition = stream.Position;
// Read some start bytes
long startPos = stream.Position;
byte[] startBytes = new byte[18];
stream.Read(startBytes, 0, 18);
stream.Position = startPos;
// Detect special image types
if (startBytes[0] == 0x44 && startBytes[1] == 0x44 && startBytes[2] == 0x53 && startBytes[3] == 0x20)
{ // dds image
return(FromPfimImage(Pfim.Dds.Create(stream, new Pfim.PfimConfig())));
}
else if (startBytes[0] == 0x38 && startBytes[1] == 0x42 && startBytes[2] == 0x50 && startBytes[3] == 0x53)
{ // psd image
PsdFile image = new PsdFile();
image.Load(stream);
using (Image image2 = ImageDecoder.DecodeImage(image))
return(FromSystemDrawingImage(image2));
}
else if (IsTga(startBytes))
{ // tga image
return(FromPfimImage(Pfim.Targa.Create(stream, new Pfim.PfimConfig())));
}
else
{ // other image
using (Image image = Image.FromStream(stream))
return(FromSystemDrawingImage(image));
}
}
private static Bitmap LoadImageFromCache(string sFile)
{
Bitmap zBitmap;
var sKey = sFile.ToLower();
if (!s_dictionaryImages.TryGetValue(sKey, out zBitmap))
{
if (s_dictionaryImages.Count > IMAGE_CACHE_MAX)
{
// TODO: this is a terrible eviction strategy
DumpImagesFromDictionary(s_dictionaryImages);
}
if (!File.Exists(sFile))
{
sFile = ProjectManager.Instance.ProjectPath + sFile;
if (!File.Exists(sFile))
{
return(null);
}
}
Bitmap zSourceImage;
try
{
switch (Path.GetExtension(sFile).ToLower())
{
case ".psd":
{
var zFile = new PsdFile();
zFile.Load(sFile);
zSourceImage = ImageDecoder.DecodeImage(zFile);
}
break;
default:
zSourceImage = new Bitmap(sFile);
break;
}
}
catch (Exception)
{
// return a purple bitmap to indicate an error
zBitmap = new Bitmap(1, 1);
Graphics.FromImage(zBitmap).FillRectangle(Brushes.Purple, 0, 0, zBitmap.Width, zBitmap.Height);
return(zBitmap);
}
zBitmap = new Bitmap(zSourceImage.Width, zSourceImage.Height);
// copy the contents into the image
Graphics zGraphics = Graphics.FromImage(zBitmap);
zGraphics.DrawImage(zSourceImage, new Rectangle(0, 0, zBitmap.Width, zBitmap.Height), 0, 0, zBitmap.Width, zBitmap.Height, GraphicsUnit.Pixel);
// duping the image into a memory copy allows the file to change (not locked by the application)
zSourceImage.Dispose();
CacheImage(s_dictionaryImages, sKey, zBitmap);
}
return(zBitmap);
}
public IList <IPsdLayer> GetLayersAndSize(Stream s, out Size size)
{
PsdFile file = new PsdFile();
file.Load(s);
size = new Size(file.Columns, file.Rows);
return(getLayers(file));
}
private void OnOpenClick(object sender, EventArgs e)
{
string fileName = m_fileName.Text;
if (File.Exists(fileName))
{
UpdateFileLst(fileName);
PsdFile pt = new PsdFile();
this.Cursor = Cursors.WaitCursor;
pt.Load(fileName);
m_fileStructure.Nodes.Clear();
TreeNode fileNode = new TreeNode("PSD File");
fileNode.Tag = pt;
m_fileStructure.Nodes.Add(fileNode);
foreach (Layer layer in pt.Layers)
{
TreeNode layerNode = new TreeNode("Layer Name=" + layer.Name);
layerNode.Tag = layer;
fileNode.Nodes.Add(layerNode);
foreach (Layer.Channel ch in layer.Channels)
{
TreeNode chNode = new TreeNode("Channel ID=" + ch.ID.ToString());
chNode.Tag = ch;
layerNode.Nodes.Add(chNode);
}
TreeNode maskNode = new TreeNode("Mask");
maskNode.Tag = layer.MaskData;
layerNode.Nodes.Add(maskNode);
TreeNode blendingNode = new TreeNode("BlendingRangesData");
blendingNode.Tag = layer.BlendingRangesData;
layerNode.Nodes.Add(blendingNode);
foreach (Layer.AdjustmentLayerInfo adjInfo in layer.AdjustmentInfo)
{
TreeNode node = new TreeNode(adjInfo.Key);
node.Tag = adjInfo;
layerNode.Nodes.Add(node);
}
}
m_fileStructure.SelectedNode = fileNode;
this.Cursor = Cursors.Default;
//pt.Save(Path.Combine(Path.GetDirectoryName(m_fileName.Text), Path.GetFileNameWithoutExtension(m_fileName.Text) + "-s.psd"));
}
}
/// <summary>
/// コンストラクタ
/// </summary>
/// <param name="filepath">入力PSDファイルパス</param>
/// <param name="nonUnicodeEncoding">非ユニコードのレイヤ名のエンコーディング</param>
public PsdSplitter(string filepath, Encoding nonUnicodeEncoding)
{
InputFilePath = Path.GetFullPath(filepath);
InputPsdFile = new PsdFile();
OutputDirPrefix = "out-";
using (var fs = new FileStream(filepath, FileMode.Open, FileAccess.Read))
{
InputPsdFile.Load(fs, nonUnicodeEncoding);
}
}
private void executeButton_Click(object sender, EventArgs e)
{
if (string.IsNullOrEmpty(folderPath) || string.IsNullOrEmpty(filePath))
{
MessageBox.Show("ファイルまたはフォルダが選択されていません");
return;
}
PsdFile psd = new PsdFile();
psd.Load(filePath);
List <string> layerName = new List <string>();
foreach (var layer in psd.Layers)
{
layerName.Add(layer.Name);
}
using (MagickImageCollection imgs = new MagickImageCollection(filePath))
{
for (int i = 0; i < imgs.Count; i++)
{
imgs[i].GifDisposeMethod = GifDisposeMethod.Background;
}
imgs.Coalesce();
for (int i = 0; i < imgs.Count; i++)
{
imgs[i].GifDisposeMethod = GifDisposeMethod.Background;
string saveFileName;
try
{
saveFileName = Path.Combine(folderPath, layerName[i] + ".png");
}
catch
{
saveFileName = "error_name";
}
imgs[i].Write(saveFileName);
}
imgs.RemoveAt(0);
}
//Application.Exit();
}
protected override Document OnLoad(System.IO.Stream input)
{
PsdFile psdFile = new PsdFile();
psdFile.Load(input);
Document document = new Document(psdFile.Columns, psdFile.Rows);
if (psdFile.Resolution != null)
{
document.DpuUnit = MeasurementUnit.Inch;
document.DpuX = psdFile.Resolution.HRes;
document.DpuY = psdFile.Resolution.VRes;
}
if (psdFile.Layers.Count == 0)
{
BitmapLayer layer = ImageDecoderPdn.DecodeImage(psdFile);
document.Layers.Add(layer);
}
else
{
PaintDotNet.Threading.PrivateThreadPool threadPool = new PaintDotNet.Threading.PrivateThreadPool();
var layersList = new List <Layer>();
foreach (PhotoshopFile.Layer l in psdFile.Layers)
{
if (!l.Rect.IsEmpty)
{
layersList.Add(null);
LoadLayerContext llc = new LoadLayerContext(l, document, BlendModeKeyToBlendOp(l), layersList, layersList.Count - 1);
WaitCallback waitCallback = new WaitCallback(llc.LoadLayer);
threadPool.QueueUserWorkItem(waitCallback);
}
}
threadPool.Drain();
foreach (var layer in layersList)
{
document.Layers.Add(layer);
}
}
return(document);
}
public Bitmap Decode(Stream s)
{
//Bitmap we will render to
System.Drawing.Bitmap b = null;
//Time just the parsing/rendering
Stopwatch swRender = new Stopwatch();
swRender.Start();
PsdFile psdFile = new PsdFile();
psdFile.Load(s);
//Load background layer
b = ImageDecoder.DecodeImage(psdFile); //Layers collection doesn't include the composed layer
//How fast?
swRender.Stop();
trace("Parsing and rendering PSD to a Bitmap instance took " + swRender.ElapsedMilliseconds.ToString(NumberFormatInfo.InvariantInfo) + "ms");
return(b);
}
private static Texture LoadSpriteSheetAbsolute(string title, string file_name)
{
// Load and decompress Photoshop file structures
var psdFile = new PsdFile();
psdFile.Load(file_name, Encoding.Default);
if (psdFile.Layers.Count == 0)
{
psdFile.BaseLayer.CreateMissingChannels();
}
var layer = psdFile.BaseLayer;
using (Bitmap bmp = new Bitmap(psdFile.ColumnCount, psdFile.RowCount)) {
using (Graphics gfx = Graphics.FromImage(bmp)) {
gfx.Clear(Color.Transparent);
var bmp_data = bmp.LockBits(layer.Rect, ImageLockMode.WriteOnly, PixelFormat.Format32bppArgb);
int pixel_size = 4 * sizeof(byte);
int idx = 0;
for (int i = 0; i < bmp_data.Height; i++)
{
for (int j = 0; j < bmp_data.Width; j++)
{
Marshal.Copy(new byte[] {
layer.Channels [2].ImageData [idx],
layer.Channels [1].ImageData [idx],
layer.Channels [0].ImageData [idx],
layer.Channels.Count >= 4 ? layer.Channels [3].ImageData [idx] : (byte)0xFF,
}, 0, new IntPtr((long)bmp_data.Scan0 + i * bmp_data.Stride + j * pixel_size), pixel_size);
idx++;
}
}
bmp.UnlockBits(bmp_data);
}
var texture = Texture.LoadTexture(title, bmp);
psdFile.SlicesToTextureRegionInfo(ref texture);
return(texture);
}
}
//이미지 가져오기( + .psd)
private byte[] OpenImage()
{
OpenFileDialog openFile = new OpenFileDialog();
openFile.DefaultExt = "jpg";
openFile.Filter = "Images Files(*.jpg; *.jpeg; *.gif; *.bmp; *.png)|*.jpg;*.jpeg;*.gif;*.bmp;*.png; *.psd";
openFile.ShowDialog();
if (openFile.FileNames.Length > 0)
{
string[] opneFileInfo = openFile.SafeFileName.Split('.');
foreach (string filename in openFile.FileNames)
{
if (opneFileInfo[1] == "psd")
{
var tmp = new PsdFile();
tmp.Load(filename);
using (Process = new MemoryStream())
{
using (var imageFactory = new ImageFactory(preserveExifData: true))
{
Bitmap img = ImageDecoder.DecodeImage(tmp);
imageFactory.Load(img)
.Save(Process);
}
return(Process.ToArray());
}
}
else
{
return(File.ReadAllBytes(filename));
}
}
}
return(null);
}
public PSDHelper(Stream stream)
{
//GB2312 = 936
_file = new PsdFile(936);
_file.Load(stream);
}
public PSDHelper(string path)
{
//GB2312 = 936
_file = new PsdFile(936);
_file.Load(path);
}
