psdparse 0.1.1__tar.gz → 0.2.1__tar.gz

{psdparse-0.1.1 → psdparse-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: psdparse
-Version: 0.1.1
+Version: 0.2.1
 Summary: Fast PSD (Photoshop) reader/writer — C++17 core with pybind11 bindings
 Keywords: psd,photoshop,parser,image,graphics
 Author-Email: wamsoft <wtnbgo@gmail.com>

{psdparse-0.1.1 → psdparse-0.2.1}/docs/PYTHON_API.md

@@ -101,6 +101,7 @@ Read-only view of one layer.
 | `channels` | `list[ChannelInfo]` | per-channel id+length |
 | `name` | `str` | raw Pascal-string name (CP932 etc on Japanese PSDs — pybind11 may raise UnicodeDecodeError when read) |
 | `name_unicode` | `str` | UTF-16 Unicode name from `luni` record (preferred) |
+| `text` | `dict` \| `None` | text-layer content & style (`None` for non-text layers) — see below |
 | `visible` | `bool` | flag bit 1 inverted |
 | `transparency_protected` | `bool` | flag bit 0 |
 | `obsolete` | `bool` | flag bit 2 |
@@ -108,6 +109,52 @@ Read-only view of one layer.
 
 **Tip:** For Japanese PSDs prefer `name_unicode` and fall back to `name` only inside a `try / except UnicodeDecodeError`.
 
+### `layer.text` — text-layer content & style
+
+For text layers (`layer_type == LayerType.TEXT`) this returns a dict parsed from
+the `TySh` type-tool block and its embedded Adobe *EngineData*. For every other
+layer it returns `None`.
+
+```python
+{
+  "text": "普通のテキスト\r二行目\r三行目",  # full string; line breaks are CR ('\r')
+  "orientation": "horizontal",              # or "vertical"
+  "justification": 0,                        # first paragraph: 0=left 1=right 2=center
+  "transform": [xx, xy, yx, yy, tx, ty],     # affine placement transform (tx,ty = translation)
+  "runs": [                                   # per-run character styling, in text order
+    {
+      "length": 8,                            # run length in UTF-16 code units (see note)
+      "font": "NotoSansJP-Thin",              # resolved font-set family name
+      "size_px": 75.0,                        # font size (pt)
+      "color": (1.0, 0.0, 0.0, 1.0),          # RGBA, each 0..1 (None if unspecified)
+      "tracking": -100,                        # letter spacing, 1/1000 em
+      "kerning": 0,                            # manual kerning
+      "auto_kerning": False,                   # metrics/optical kerning enabled
+    },
+    ...
+  ],
+}
+```
+
+Notes:
+- **`length` is in UTF-16 code units**, matching Photoshop's EngineData
+  `RunLengthArray`. Astral characters (e.g. emoji) count as 2. To slice the
+  text by runs, index into `text.encode("utf-16-le")` (2 bytes per unit) rather
+  than the Python `str` (which is code-point indexed).
+- Adjacent runs may share identical styling — Photoshop stores runs as authored,
+  so the run split does not always coincide with a style change.
+- `color` is decoded from EngineData's `FillColor /Type 1` (RGB) and reordered
+  from its on-disk `[A R G B]` to `(R, G, B, A)`. Non-RGB fill types are not yet
+  decoded (`color` is `None`).
+
+```python
+for layer in p.layers:
+    t = layer.text
+    if t is None:
+        continue
+    print(t["text"], "→", {r["font"] for r in t["runs"]})
+```
+
 ## Enums
 
 ```python

{psdparse-0.1.1 → psdparse-0.2.1}/docs/ROADMAP.md

@@ -71,6 +71,13 @@ This is mostly a constructor that fills `Data` with a minimal-but-valid skeleton
 
 ## Other future work
 
+- ✅ **Text layer content extraction (`TySh` type-tool additional info).** *Done 2026-07-27.* `lay.text` returns `{"text", "orientation", "justification", "transform", "runs":[{"length","font","size_px","color","tracking","kerning","auto_kerning"}]}` (or `None` for non-text layers). Implementation: `psddesc` now reads `tdta` raw data (length-prefixed), `loadLayerTypeTool` (`psdlayer.cpp`) parses the `TySh` header + text descriptor, and `psdengine.cpp` parses the embedded Adobe *EngineData* mini-language (FontSet / StyleRun / ParagraphRun) into per-run styling. Validated against `tests/data/fontsample.psd` (multi-font/size/color, **vertical**, emoji, tracking) — see `tests/test_text.py`.
+
+  **Deferred (need targeted sample PSDs, next turn):**
+  - **Non-RGB `FillColor`** — only `/Type 1` (RGB) decoded today; grayscale-mode / CMYK-mode text needs a sample to confirm `/Type` + `/Values` layout.
+  - **Warp text** — lives in the `TySh` *warp* descriptor (currently skipped, not in EngineData); needs samples with each warp style + non-zero bend/distortion.
+  - **Area (paragraph) vs point text / text box bounds** and **text-on-path** — need samples.
+  - **Leading / faux bold-italic / underline / strikethrough / paragraph indent+spacing** — keys exist in EngineData but are default-valued in the current sample, so per-run extraction can't be verified yet; needs a sample authored with non-default values.
 - 16-bit (`Lr16`) and 32-bit-float (`Lr32`) layer data: currently captured in `layerAndMaskTrailing` for round-trip but not exposed as decoded pixels.
 - Layer mask: parse + re-emission for masks > 20 bytes (real mask, vector mask flag, density / feather).
 - Image resources: most are currently passed through as raw bytes. Higher-level accessors for ICC profile, EXIF, thumbnail, version info, etc. would be nice for tools.

{psdparse-0.1.1 → psdparse-0.2.1}/psdparse/CMakeLists.txt

@@ -37,6 +37,7 @@ endif()
 add_library(${PROJECT_NAME} STATIC
 	bmp.cpp
 	psddesc.cpp
+	psdengine.cpp
 	psdfile.cpp
 	psdimage.cpp
 	psdlayer.cpp

{psdparse-0.1.1 → psdparse-0.2.1}/psdparse/bmp.cpp

@@ -3,6 +3,7 @@
 #include <cstring>
 #include <fstream>
 #include <iostream>
+#include <cstring>
 
 namespace psd {
 

{psdparse-0.1.1 → psdparse-0.2.1}/psdparse/psddata.h

@@ -5,6 +5,7 @@
 #include "psddesc.h"
 
 #include <vector>
+#include <cstring>
 
 namespace psd {
   // レイヤタイプ
@@ -156,6 +157,8 @@ namespace psd {
 		int width;
 		int depth;
 		int mode;
+		double hres = 72.0;   // 水平解像度 dpi (image resource 1005)。 既定 72。
+		double vres = 72.0;   // 垂直解像度 dpi。
 	};
 
   // RGBAカラー
@@ -391,6 +394,40 @@ namespace psd {
     bool isMaskChannel() const { return (id == -3 || id == -2); }
 	};
 
+  // テキストレイヤの文字スタイルラン。EngineData の StyleRun/RunArray の
+  // 1 エントリに対応し、length は本文の何文字分に適用されるか (RunLengthArray)。
+  struct TextStyleRun {
+    int         length;      // 適用文字数 (UTF-16 コードユニット)
+    u16str      font;        // 解決済みフォント名 (FontSet を index で引いたもの)
+    float       fontSize;    // pt
+    float       color[4];    // RGBA 0..1 (EngineData の ARGB を並べ替えて格納)
+    bool        hasColor;    // FillColor が指定されていたか
+    int         tracking;    // トラッキング (字送り, 1/1000 em)
+    int         kerning;     // 手動カーニング
+    bool        autoKerning; // 自動カーニング (メトリクス/オプティカル) 有効
+    bool        sizeInherited; // FontSize を既定 StyleSheet から継承したか。
+                               // 継承分は nominal pt なので dpi/72 で px 化する
+                               // (明示 run の FontSize は既に解決済み px)。内部用。
+
+    TextStyleRun()
+      : length(0), fontSize(0.0f), color{0,0,0,1}, hasColor(false),
+        tracking(0), kerning(0), autoKerning(false), sizeInherited(false) {}
+  };
+
+  // テキストレイヤ情報 (追加レイヤ情報 'TySh' 由来)。
+  struct TextLayerData {
+    bool        present;         // テキストレイヤとしてパースできたか
+    u16str      text;            // 本文全体 (改行は \r)
+    double      transform[6];    // アフィン変換 xx,xy,yx,yy,tx,ty
+    std::string orientation;     // "horizontal" / "vertical"
+    int         justification;   // 段落の行揃え 0=左 1=右 2=中央 (先頭段落)
+    std::vector<TextStyleRun> runs;
+
+    TextLayerData()
+      : present(false), transform{1,0,0,1,0,0},
+        justification(0) {}
+  };
+
 	// レイヤ情報
   class Data;
 	struct LayerInfo {
@@ -426,6 +463,9 @@ namespace psd {
     std::map<int, LayerCompInfo> layerComps;
     Descriptor layerCompDesc; // ディスクリプタ形式で全メタデータを格納
 
+    // テキストレイヤ情報 ('TySh' 由来)。layerType==TEXT のとき present=true。
+    TextLayerData textData;
+
     // 親フォルダレイヤ
     LayerInfo *parent;
 

{psdparse-0.1.1 → psdparse-0.2.1}/psdparse/psddesc.cpp

@@ -39,11 +39,7 @@ namespace psd {
     case 'type':
     case 'GlbC': item = new DescriptorClass(type);   break;
     case 'alis': item = new DescriptorAlias();       break;
-    case 'tdta':
-      // undocumented なうえ、サイズ情報もなくスキップできないので
-      // これが出てきたらこれ以上はパースできない
-      // item = new DescriptorRawData(data);
-      break;
+    case 'tdta': item = new DescriptorRawData();     break;
     default:
       break;
     }
@@ -187,6 +183,21 @@ namespace psd {
     return true;
   }
 
+  bool
+  DescriptorRawData::load(IteratorBase *data)
+  {
+    int size = data->getInt32();
+    if (size < 0 || size > data->rest()) {
+      isValid = false;
+      return false;
+    }
+    bytes.resize((size_t)size);
+    if (size > 0) {
+      data->getData(&bytes[0], size);
+    }
+    return true;
+  }
+
   bool
   DescriptorAlias::load(IteratorBase *data)
   {

{psdparse-0.1.1 → psdparse-0.2.1}/psdparse/psddesc.h

@@ -361,13 +361,17 @@ namespace psd {
     std::string alias;
   };
 
-  // Raw は値の解釈がデータ次第でサイズがわからないので失敗扱いにしている
+  // Raw data ('tdta'): 4-byte length prefix followed by that many bytes.
+  // Used by the type-tool 'TySh' descriptor to carry the EngineData blob
+  // (Adobe's text-engine mini-language, parsed separately by psdengine).
   struct DescriptorRawData : DescriptorItem {
-    DescriptorRawData(IteratorBase *data) : DescriptorItem(TYPE_RAW_DATA) {}
-    virtual bool load(IteratorBase *data) { return false; }
+    DescriptorRawData() : DescriptorItem(TYPE_RAW_DATA) {}
+    virtual bool load(IteratorBase *data);
     virtual void dump(int indent) {
-      dprint("%s\n", typeName());
+      dprint("%s (size:%zd)\n", typeName(), bytes.size());
     }
+
+    std::string bytes;
   };
 
   // --------------------------------------------------------------------------

psdparse-0.2.1/psdparse/psdengine.cpp

@@ -0,0 +1,305 @@
+#include "psdengine.h"
+
+#include <cstdlib>
+#include <map>
+#include <string>
+#include <vector>
+
+namespace psd {
+namespace {
+
+  // --------------------------------------------------------------------------
+  // パース済みツリー
+  // --------------------------------------------------------------------------
+  struct Node {
+    enum Kind { DICT, ARRAY, STRING, NUMBER, BOOL } kind;
+    std::map<std::string, Node*> dict;
+    std::vector<Node*>           arr;
+    std::string                  str;   // STRING: 生バイト (UTF-16BE, BOM 含む)
+    double                       num;
+    bool                         bl;
+
+    Node(Kind k) : kind(k), num(0), bl(false) {}
+    ~Node() {
+      for (std::map<std::string, Node*>::iterator it = dict.begin(); it != dict.end(); ++it)
+        delete it->second;
+      for (size_t i = 0; i < arr.size(); i++)
+        delete arr[i];
+    }
+  };
+
+  // --------------------------------------------------------------------------
+  // トークナイザ兼再帰下降パーサ
+  // --------------------------------------------------------------------------
+  struct Parser {
+    const unsigned char *p;
+    const unsigned char *end;
+    int depth; // 異常データでの無限再帰を防ぐガード
+
+    Parser(const char *d, size_t n)
+      : p((const unsigned char*)d), end((const unsigned char*)d + n), depth(0) {}
+
+    void skipWs() {
+      while (p < end) {
+        unsigned char c = *p;
+        if (c == ' ' || c == '\t' || c == '\r' || c == '\n') p++;
+        else break;
+      }
+    }
+
+    static bool isDelim(unsigned char c) {
+      return c == ' ' || c == '\t' || c == '\r' || c == '\n' ||
+             c == '/' || c == '<'  || c == '>'  || c == '['  ||
+             c == ']' || c == '('  || c == ')';
+    }
+
+    Node *parseValue() {
+      skipWs();
+      if (p >= end) return 0;
+      unsigned char c = *p;
+      if (c == '<' && p + 1 < end && p[1] == '<') return parseDict();
+      if (c == '[') return parseArray();
+      if (c == '(') return parseString();
+      return parseToken();
+    }
+
+    Node *parseDict() {
+      p += 2; // "<<"
+      Node *n = new Node(Node::DICT);
+      if (++depth > 200) { --depth; return n; }
+      while (p < end) {
+        skipWs();
+        if (p >= end) break;
+        if (*p == '>' && p + 1 < end && p[1] == '>') { p += 2; break; }
+        if (*p == '/') {
+          std::string key = parseName();
+          Node *v = parseValue();
+          if (v) {
+            std::map<std::string, Node*>::iterator it = n->dict.find(key);
+            if (it != n->dict.end()) delete it->second;
+            n->dict[key] = v;
+          }
+        } else {
+          p++; // 想定外バイト: 前進して無限ループ回避
+        }
+      }
+      --depth;
+      return n;
+    }
+
+    Node *parseArray() {
+      p++; // '['
+      Node *n = new Node(Node::ARRAY);
+      if (++depth > 200) { --depth; return n; }
+      while (p < end) {
+        skipWs();
+        if (p >= end) break;
+        if (*p == ']') { p++; break; }
+        Node *v = parseValue();
+        if (v) n->arr.push_back(v);
+        else   p++;
+      }
+      --depth;
+      return n;
+    }
+
+    std::string parseName() {
+      p++; // '/'
+      std::string s;
+      while (p < end && !isDelim(*p)) { s.push_back((char)*p); p++; }
+      return s;
+    }
+
+    // PDF 風の文字列。( ) は入れ子でバランスし、\ は次の 1 バイトをリテラル化。
+    // 中身は UTF-16BE の生バイト列としてそのまま保持する。
+    Node *parseString() {
+      p++; // '('
+      Node *n = new Node(Node::STRING);
+      int d = 1;
+      while (p < end) {
+        unsigned char c = *p++;
+        if (c == '\\') {
+          if (p < end) { n->str.push_back((char)*p); p++; }
+          continue;
+        }
+        if (c == '(') { d++; n->str.push_back('('); continue; }
+        if (c == ')') { if (--d == 0) break; n->str.push_back(')'); continue; }
+        n->str.push_back((char)c);
+      }
+      return n;
+    }
+
+    Node *parseToken() {
+      std::string s;
+      while (p < end && !isDelim(*p)) { s.push_back((char)*p); p++; }
+      if (s.empty()) { if (p < end) p++; return 0; }
+      if (s == "true" || s == "false") {
+        Node *n = new Node(Node::BOOL);
+        n->bl = (s == "true");
+        return n;
+      }
+      Node *n = new Node(Node::NUMBER);
+      n->num = atof(s.c_str());
+      return n;
+    }
+  };
+
+  // --------------------------------------------------------------------------
+  // 抽出ヘルパ
+  // --------------------------------------------------------------------------
+  Node *dget(Node *n, const char *key) {
+    if (!n || n->kind != Node::DICT) return 0;
+    std::map<std::string, Node*>::iterator it = n->dict.find(key);
+    return it == n->dict.end() ? 0 : it->second;
+  }
+
+  // STRING ノードの生バイト (UTF-16BE / BOM 付き) を u16str へ。
+  u16str toU16(Node *n) {
+    u16str out;
+    if (!n || n->kind != Node::STRING) return out;
+    const std::string &raw = n->str;
+    size_t i = 0;
+    if (raw.size() >= 2 &&
+        (unsigned char)raw[0] == 0xFE && (unsigned char)raw[1] == 0xFF) {
+      i = 2; // BOM
+    }
+    for (; i + 1 < raw.size(); i += 2) {
+      unsigned short hi = (unsigned char)raw[i];
+      unsigned short lo = (unsigned char)raw[i + 1];
+      out.push_back((char16_t)((hi << 8) | lo));
+    }
+    return out;
+  }
+
+} // anonymous namespace
+
+  bool parseEngineData(const char *data, size_t len, TextLayerData &out)
+  {
+    Parser ps(data, len);
+    Node *root = ps.parseValue();
+    if (!root || root->kind != Node::DICT) { delete root; return false; }
+
+    bool haveText = false;
+    Node *engine = dget(root, "EngineDict");
+
+    // 本文
+    if (engine) {
+      Node *editor = dget(engine, "Editor");
+      Node *text   = dget(editor, "Text");
+      if (text && text->kind == Node::STRING) {
+        out.text = toU16(text);
+        haveText = true;
+      }
+    }
+
+    // フォント名テーブル (ResourceDict/FontSet[]/Name)
+    std::vector<u16str> fonts;
+    {
+      Node *rd = dget(root, "ResourceDict");
+      Node *fs = dget(rd, "FontSet");
+      if (fs && fs->kind == Node::ARRAY) {
+        for (size_t i = 0; i < fs->arr.size(); i++) {
+          fonts.push_back(toU16(dget(fs->arr[i], "Name")));
+        }
+      }
+    }
+
+    // 既定 StyleSheet (ResourceDict/StyleSheetSet[0]/StyleSheetData)。
+    // box text の基準 run は FontSize/Font 等の StyleSheetData を持たず、 この既定を
+    // 継承する。 これを読まないと FontSize=0 になる (実表示は既定サイズ)。
+    float defSize = 0.0f; int defFontIdx = -1; int defTracking = 0;
+    float defColor[4] = {0, 0, 0, 1}; bool defHasColor = false;
+    {
+      Node *rd2 = dget(root, "ResourceDict");
+      Node *sss = dget(rd2, "StyleSheetSet");
+      Node *dssd = 0;
+      if (sss && sss->kind == Node::ARRAY && !sss->arr.empty()) {
+        dssd = dget(sss->arr[0], "StyleSheetData");
+        if (!dssd) dssd = dget(dget(sss->arr[0], "StyleSheet"), "StyleSheetData");
+      }
+      if (dssd) {
+        Node *f = dget(dssd, "Font");
+        if (f && f->kind == Node::NUMBER) defFontIdx = (int)f->num;
+        Node *fs = dget(dssd, "FontSize");
+        if (fs && fs->kind == Node::NUMBER) defSize = (float)fs->num;
+        Node *tk = dget(dssd, "Tracking");
+        if (tk && tk->kind == Node::NUMBER) defTracking = (int)tk->num;
+        Node *vals = dget(dget(dssd, "FillColor"), "Values");
+        if (vals && vals->kind == Node::ARRAY && vals->arr.size() >= 4) {
+          defColor[3] = (float)vals->arr[0]->num; // A
+          defColor[0] = (float)vals->arr[1]->num; // R
+          defColor[1] = (float)vals->arr[2]->num; // G
+          defColor[2] = (float)vals->arr[3]->num; // B
+          defHasColor = true;
+        }
+      }
+    }
+
+    // ラン単位スタイル (EngineDict/StyleRun)
+    if (engine) {
+      Node *styleRun = dget(engine, "StyleRun");
+      Node *runArray = dget(styleRun, "RunArray");
+      Node *runLen   = dget(styleRun, "RunLengthArray");
+      if (runArray && runArray->kind == Node::ARRAY) {
+        for (size_t i = 0; i < runArray->arr.size(); i++) {
+          Node *ssd = dget(dget(runArray->arr[i], "StyleSheet"), "StyleSheetData");
+          TextStyleRun r;
+          // 既定を先に適用 (未指定フィールドの継承)。
+          r.fontSize = defSize;
+          r.sizeInherited = true;   // 既定継承 (下で run が上書きすれば false)
+          r.tracking = defTracking;
+          if (defFontIdx >= 0 && defFontIdx < (int)fonts.size()) r.font = fonts[defFontIdx];
+          if (defHasColor) {
+            r.color[0] = defColor[0]; r.color[1] = defColor[1];
+            r.color[2] = defColor[2]; r.color[3] = defColor[3];
+            r.hasColor = true;
+          }
+          if (runLen && runLen->kind == Node::ARRAY && i < runLen->arr.size() &&
+              runLen->arr[i]->kind == Node::NUMBER) {
+            r.length = (int)runLen->arr[i]->num;
+          }
+          if (ssd) {
+            Node *fidx = dget(ssd, "Font");
+            if (fidx && fidx->kind == Node::NUMBER) {
+              int idx = (int)fidx->num;
+              if (idx >= 0 && idx < (int)fonts.size()) r.font = fonts[idx];
+            }
+            Node *fsz = dget(ssd, "FontSize");
+            if (fsz && fsz->kind == Node::NUMBER) {
+              r.fontSize = (float)fsz->num;   // 明示 = 解決済み px
+              r.sizeInherited = false;
+            }
+            Node *trk = dget(ssd, "Tracking");
+            if (trk && trk->kind == Node::NUMBER) r.tracking = (int)trk->num;
+            Node *krn = dget(ssd, "Kerning");
+            if (krn && krn->kind == Node::NUMBER) r.kerning = (int)krn->num;
+            Node *akn = dget(ssd, "AutoKerning");
+            if (akn && akn->kind == Node::BOOL) r.autoKerning = akn->bl;
+            Node *vals = dget(dget(ssd, "FillColor"), "Values");
+            if (vals && vals->kind == Node::ARRAY && vals->arr.size() >= 4) {
+              // EngineData の FillColor/Values は [A R G B]。RGBA へ並べ替える。
+              r.color[3] = (float)vals->arr[0]->num; // A
+              r.color[0] = (float)vals->arr[1]->num; // R
+              r.color[1] = (float)vals->arr[2]->num; // G
+              r.color[2] = (float)vals->arr[3]->num; // B
+              r.hasColor = true;
+            }
+          }
+          out.runs.push_back(r);
+        }
+      }
+
+      // 行揃え (先頭段落の Justification)
+      Node *paraArr = dget(dget(engine, "ParagraphRun"), "RunArray");
+      if (paraArr && paraArr->kind == Node::ARRAY && !paraArr->arr.empty()) {
+        Node *props = dget(dget(paraArr->arr[0], "ParagraphSheet"), "Properties");
+        Node *just  = dget(props, "Justification");
+        if (just && just->kind == Node::NUMBER) out.justification = (int)just->num;
+      }
+    }
+
+    delete root;
+    return haveText;
+  }
+
+} // namespace psd

psdparse-0.2.1/psdparse/psdengine.h

@@ -0,0 +1,34 @@
+#ifndef __psdengine_h__
+#define __psdengine_h__
+
+#include "psddata.h"
+
+#include <cstddef>
+
+namespace psd {
+
+  // Adobe "EngineData" (テキストエンジンのシリアライズ表現) を解析し、
+  // TextLayerData の text / runs / justification / orientation を埋める。
+  //
+  // EngineData は Descriptor とは別物の独自ミニ言語で、次の要素からなる:
+  //   <<  >>        辞書 ( /key value の並び )
+  //   [  ]          配列
+  //   ( ... )       文字列 (UTF-16BE, BOM 付き。( ) \ は \ でエスケープ)
+  //   /name         キー
+  //   123 / -1.5    数値
+  //   true / false  真偽
+  //
+  // 抽出するのは:
+  //   EngineDict/Editor/Text                     … 本文
+  //   ResourceDict/FontSet[]/Name                … フォント名テーブル
+  //   EngineDict/StyleRun/RunArray[]             … ラン単位スタイル
+  //     StyleSheet/StyleSheetData/{Font,FontSize,FillColor}
+  //   EngineDict/StyleRun/RunLengthArray         … 各ランの文字数
+  //   EngineDict/ParagraphRun/RunArray[0]/…/Justification … 行揃え
+  //
+  // 本文 (Editor/Text) が取得できたら true を返す。
+  bool parseEngineData(const char *data, size_t len, TextLayerData &out);
+
+} // namespace psd
+
+#endif // __psdengine_h__

{psdparse-0.1.1 → psdparse-0.2.1}/psdparse/psdimage.cpp

@@ -11,6 +11,7 @@
 #define NOMINMAX
 #include <zlib.h>
 #endif
+#include <cstring>
 
 // #define ENABLE_BMP_OUTPUT
 #ifdef ENABLE_BMP_OUTPUT

{psdparse-0.1.1 → psdparse-0.2.1}/psdparse/psdlayer.cpp

@@ -1,6 +1,7 @@
 
 #include "psddata.h"
 #include "psddesc.h"
+#include "psdengine.h"
 #include <cstring>
 
 namespace psd {
@@ -113,4 +114,49 @@ namespace psd {
     return true;
   }
 
+  // 'TySh' Type tool object setting (Photoshop 6.0+)。
+  //   version(2) transform(double*6) textVer(2) descVer(4) <text descriptor>
+  //   warpVer(2) descVer(4) <warp descriptor> left top right bottom
+  // text descriptor の 'Txt ' に本文、'EngineData'(tdta) にラン単位スタイルが入る。
+  bool loadLayerTypeTool(LayerInfo &layer, AdditionalLayerInfo &additional)
+  {
+    IteratorBase *r = additional.data;
+    TextLayerData &td = layer.textData;
+
+    int version = r->getInt16(); // = 1
+    (void)version;
+    for (int i = 0; i < 6; i++) {
+      pun64 v;
+      v.i = r->getInt64();
+      td.transform[i] = v.f;
+    }
+    int textVer = r->getInt16(); // = 50
+    (void)textVer;
+    int descVer = r->getInt32(); // = 16
+    (void)descVer;
+
+    Descriptor text;
+    if (!text.load(r)) {
+      // 途中まで読めていれば itemMap には有効な項目が入っている
+    }
+
+    // 本文 ('Txt ' — キー末尾に空白)。EngineData が取れれば後で上書きされる。
+    DescriptorString *txt = text.item("Txt ");
+    if (txt) td.text = txt->val;
+
+    // 縦横 ('Ornt' enum: Hrzn / Vrtc)
+    DescriptorEnumerated *ornt = text.item("Ornt");
+    td.orientation = (ornt && ornt->enumId == "Vrtc") ? "vertical" : "horizontal";
+
+    // ラン単位スタイル (EngineData)
+    DescriptorRawData *eng = text.item("EngineData");
+    if (eng && !eng->bytes.empty()) {
+      parseEngineData(eng->bytes.data(), eng->bytes.size(), td);
+    }
+
+    td.present = true;
+    layer.layerType = LAYER_TYPE_TEXT;
+    return true;
+  }
+
 } // namespace psd

{psdparse-0.1.1 → psdparse-0.2.1}/psdparse/psdlayer.h

@@ -9,5 +9,6 @@ namespace psd {
   bool loadLayerId(LayerInfo &layer, AdditionalLayerInfo &additional);
   bool loadLayerMetadata(LayerInfo &layer, AdditionalLayerInfo &additional);
   bool loadLayerFillOpacity(LayerInfo &layer, AdditionalLayerInfo &additional);
+  bool loadLayerTypeTool(LayerInfo &layer, AdditionalLayerInfo &additional);
 }
 #endif //  __psdlayer_h__

{psdparse-0.1.1 → psdparse-0.2.1}/psdparse/psdparse.cpp

@@ -35,11 +35,22 @@ Data::processParsed()
       success = loadResourceLayerComps(*this, res);
       break;
 
+    case 1005: { // 0x03ED -- ResolutionInfo。 hRes/vRes は Fixed 16.16 の dpi。
+      if (res.data) {
+        int32_t h = res.data->getInt32();   // hRes (Fixed 16.16)
+        (void)res.data->getInt16();         // hResUnit
+        (void)res.data->getInt16();         // widthUnit
+        int32_t v = res.data->getInt32();   // vRes (Fixed 16.16)
+        if (h > 0) header.hres = (double)(uint32_t)h / 65536.0;
+        if (v > 0) header.vres = (double)(uint32_t)v / 65536.0;
+      }
+      break;
+    }
+
     default: // 未実装はそのままスルー
     case 1000:  // 0x03E8 -- (Obsolete--Photoshop 2.0 only ) Contains five 2-byte values: number of channels, rows, columns, depth, and mode
     case 1001:  // 0x03E9 -- Macintosh print manager print info record
     case 1003:  // 0x03EB -- (Obsolete--Photoshop 2.0 only ) Indexed color table
-    case 1005:  // 0x03ED -- ResolutionInfo structure. See Appendix A in Photoshop API Guide.pdf.
     case 1006:  // 0x03EE -- Names of the alpha channels as a series of Pascal strings.
     case 1007:  // 0x03EF -- (Obsolete) See ID 1077DisplayInfo structure. See Appendix A in Photoshop API Guide.pdf.
     case 1008:  // 0x03F0 -- The caption as a Pascal string.
@@ -224,7 +235,10 @@ Data::processParsed()
       case 'iOpa': // fill opacity
         success = loadLayerFillOpacity(layer, additional);
         break;
-        
+      case 'TySh': // Type tool object setting (Photoshop 6.0) — テキストレイヤ
+        success = loadLayerTypeTool(layer, additional);
+        break;
+
       // --- 未対応 ---
       case 'lrFX': // Effects Layer (Photoshop 5.0)
       case 'tySh': // Type Tool Info (Photoshop 5.0 and 5.5 only)
@@ -242,7 +256,6 @@ Data::processParsed()
       case 'brst': // Channel blending restrictions setting (Photoshop 6.0)
       case 'vmsk': // Vector mask setting (Photoshop 6.0)
       case 'vsms':
-      case 'TySh': // Type tool object setting (Photoshop 6.0)
       case 'ffxi': // Foreign effect ID (Photoshop 6.0)
       case 'lnsr': // Layer name source setting (Photoshop 6.0)
       case 'shpa': // Pattern data (Photoshop 6.0)
@@ -293,6 +306,23 @@ Data::processParsed()
     }
   }
 
+  // テキスト run の FontSize を px に正規化する (レイヤ解析後・解像度確定後)。 明示
+  // run の FontSize は既に解決済み px だが、 既定 StyleSheet から継承した分は nominal
+  // pt なので dpi/72 を掛ける (300dpi なら 12pt → 50px)。
+  {
+    double sc = header.hres / 72.0;
+    if (sc != 1.0) {
+      for (uint32_t li = 0; li < layerList.size(); li++) {
+        TextLayerData &td = layerList[li].textData;
+        if (!td.present) continue;
+        for (size_t ri = 0; ri < td.runs.size(); ri++) {
+          if (td.runs[ri].sizeInherited)
+            td.runs[ri].fontSize *= (float)sc;
+        }
+      }
+    }
+  }
+
   return success;
 }
 

{psdparse-0.1.1 → psdparse-0.2.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "scikit_build_core.build"
 
 [project]
 name = "psdparse"
-version = "0.1.1"
+version = "0.2.1"
 description = "Fast PSD (Photoshop) reader/writer — C++17 core with pybind11 bindings"
 readme = "README.md"
 requires-python = ">=3.9"

{psdparse-0.1.1 → psdparse-0.2.1}/python/psdparse_module.cpp

@@ -36,6 +36,36 @@ py::bytes mergedImage(psd::PSDFile &self) {
   return py::bytes(buf);
 }
 
+// Text-layer info ('TySh') as a dict, or None for non-text layers.
+py::object layerText(const psd::LayerInfo &l) {
+  if (!l.textData.present) return py::none();
+  const psd::TextLayerData &t = l.textData;
+  py::dict d;
+  d["text"] = py::cast(t.text);            // str (\r line breaks, as authored)
+  d["orientation"] = t.orientation;        // "horizontal" / "vertical"
+  d["justification"] = t.justification;    // 0=left 1=right 2=center (first paragraph)
+  py::list tf;
+  for (int i = 0; i < 6; i++) tf.append(t.transform[i]);
+  d["transform"] = tf;                     // affine xx,xy,yx,yy,tx,ty
+  py::list runs;
+  for (const auto &r : t.runs) {
+    py::dict rd;
+    rd["length"]       = r.length;         // UTF-16 code units covered by this run
+    rd["font"]         = py::cast(r.font); // resolved font-set name
+    rd["size_px"]      = r.fontSize;       // px (文書解像度で換算済み; 継承分は pt×dpi/72)
+    rd["tracking"]     = r.tracking;       // 1/1000 em
+    rd["kerning"]      = r.kerning;        // manual kerning
+    rd["auto_kerning"] = r.autoKerning;    // metrics/optical kerning on
+    if (r.hasColor)
+      rd["color"] = py::make_tuple(r.color[0], r.color[1], r.color[2], r.color[3]); // RGBA 0..1
+    else
+      rd["color"] = py::none();
+    runs.append(rd);
+  }
+  d["runs"] = runs;
+  return std::move(d);
+}
+
 py::bytes layerImage(psd::PSDFile &self, int index, const std::string &mode) {
   if (!self.isLoaded) throw std::runtime_error("PSD not loaded");
   if (index < 0 || index >= (int)self.layerList.size())
@@ -104,7 +134,9 @@ PYBIND11_MODULE(psdparse, m) {
     .def_readonly("height",   &psd::Header::height)
     .def_readonly("width",    &psd::Header::width)
     .def_readonly("depth",    &psd::Header::depth)
-    .def_readonly("mode",     &psd::Header::mode);
+    .def_readonly("mode",     &psd::Header::mode)
+    .def_readonly("hres",     &psd::Header::hres)   // 水平解像度 dpi (既定 72)
+    .def_readonly("vres",     &psd::Header::vres);  // 垂直解像度 dpi
 
   py::class_<psd::ChannelInfo>(m, "ChannelInfo")
     .def_readonly("id",     &psd::ChannelInfo::id)
@@ -132,6 +164,9 @@ PYBIND11_MODULE(psdparse, m) {
     .def_property_readonly("name_unicode", [](const psd::LayerInfo &l) {
         return u16ToStr(l.layerNameUnicode);
     })
+    .def_property_readonly("text", &layerText,
+        "Text-layer content/style as a dict (keys: text, orientation, "
+        "justification, transform, runs[]), or None for non-text layers.")
     .def_property_readonly("visible",                [](const psd::LayerInfo &l){ return l.isVisible(); })
     .def_property_readonly("transparency_protected", [](const psd::LayerInfo &l){ return l.isTransparencyProtected(); })
     .def_property_readonly("obsolete",               [](const psd::LayerInfo &l){ return l.isObsolete(); })

{psdparse-0.1.1 → psdparse-0.2.1}/tests/conftest.py

@@ -53,6 +53,11 @@ def sample_large_psd():
     return _find_sample("園部由夏_a.psd", "large.psd")
 
 
+@pytest.fixture(scope="session")
+def sample_text_psd():
+    return _find_sample("fontsample.psd")
+
+
 @pytest.fixture
 def psd_ui(sample_ui_psd):
     p = psdparse.PSDFile()
@@ -60,6 +65,13 @@ def psd_ui(sample_ui_psd):
     return p
 
 
+@pytest.fixture
+def psd_text(sample_text_psd):
+    p = psdparse.PSDFile()
+    assert p.load(str(sample_text_psd))
+    return p
+
+
 @pytest.fixture
 def psd_large(sample_large_psd):
     p = psdparse.PSDFile()

psdparse-0.2.1/tests/test_text.py

@@ -0,0 +1,111 @@
+"""Text-layer extraction ('TySh' / EngineData).
+
+Validated against tests/data/fontsample.psd, a purpose-built PSD with four
+text layers exercising line breaks, emoji (surrogate pairs), vertical text,
+and mid-string font/size/color changes.
+"""
+import psdparse
+
+
+def _text_layers(p):
+    return [l for l in p.layers if l.text is not None]
+
+
+def test_non_text_layer_returns_none(psd_text):
+    # The '背景' raster layer must not be reported as a text layer.
+    bg = psd_text.layers[0]
+    assert bg.text is None
+    assert bg.layer_type != psdparse.LayerType.TEXT
+
+
+def test_text_layers_detected(psd_text):
+    txt = _text_layers(psd_text)
+    # fontsample.psd has 4 text layers.
+    assert len(txt) == 4
+    for l in txt:
+        assert l.layer_type == psdparse.LayerType.TEXT
+
+
+def test_text_dict_shape(psd_text):
+    t = _text_layers(psd_text)[0].text
+    assert set(t) >= {"text", "orientation", "justification", "transform", "runs"}
+    assert isinstance(t["text"], str)
+    assert len(t["transform"]) == 6
+    assert t["orientation"] in ("horizontal", "vertical")
+
+
+def test_multiline_content(psd_text):
+    # First text layer: three lines separated by CR.
+    layer = _text_layers(psd_text)[0]
+    assert layer.text["text"] == "普通のテキスト\r二行目\r三行目\r\r"
+
+
+def test_vertical_orientation(psd_text):
+    # The '縦書き' layer is authored as vertical (tate-gaki) text.
+    layer = next(l for l in _text_layers(psd_text)
+                 if "縦書き" in l.text["text"])
+    assert layer.text["orientation"] == "vertical"
+    # ...and the horizontal ones report horizontal.
+    horiz = [l for l in _text_layers(psd_text)
+             if l.text["orientation"] == "horizontal"]
+    assert len(horiz) == 3
+
+
+def test_emoji_surrogate_pairs(psd_text):
+    layer = next(l for l in _text_layers(psd_text)
+                 if l.text["text"].startswith("🍥"))
+    assert layer.text["text"] == "🍥🍑🍒\r"
+
+
+def test_run_lengths_sum_to_text_length(psd_text):
+    # Run lengths are counted in UTF-16 code units (astral chars such as emoji
+    # count as 2), matching Photoshop's EngineData RunLengthArray.
+    for l in _text_layers(psd_text):
+        t = l.text
+        assert t["runs"], "expected at least one style run"
+        total = sum(r["length"] for r in t["runs"])
+        utf16_units = len(t["text"].encode("utf-16-le")) // 2
+        assert total == utf16_units
+
+
+def test_font_names_resolved(psd_text):
+    fonts = set()
+    for l in _text_layers(psd_text):
+        for r in l.text["runs"]:
+            fonts.add(r["font"])
+    # FontSet index -> name resolution should surface the real families used.
+    assert "NotoSansJP-Thin" in fonts
+    assert "SourceHanSansJP-Normal" in fonts
+
+
+def test_mid_string_style_changes(psd_text):
+    # The layer whose name advertises font/size/color changes mid-string.
+    layer = next(l for l in _text_layers(psd_text)
+                 if l.text["text"].startswith("フォントを途中でかえる"))
+    runs = layer.text["runs"]
+    # more than one distinct font, size, and color across runs
+    assert len({r["font"] for r in runs}) >= 2
+    assert len({r["size_px"] for r in runs}) >= 2
+    # a blue run (B channel dominant) exists among otherwise-red text
+    assert any(r["color"] and r["color"][2] > 0.5 for r in runs)
+    assert any(r["color"] and r["color"][0] > 0.5 for r in runs)
+
+
+def test_run_has_tracking_kerning(psd_text):
+    for l in _text_layers(psd_text):
+        for r in l.text["runs"]:
+            assert isinstance(r["tracking"], int)
+            assert isinstance(r["kerning"], int)
+            assert isinstance(r["auto_kerning"], bool)
+    # fontsample.psd was authored with -100 tracking across its runs.
+    all_runs = [r for l in _text_layers(psd_text) for r in l.text["runs"]]
+    assert any(r["tracking"] == -100 for r in all_runs)
+
+
+def test_color_is_rgba_alpha_last(psd_text):
+    for l in _text_layers(psd_text):
+        for r in l.text["runs"]:
+            if r["color"] is not None:
+                assert len(r["color"]) == 4
+                # opaque text -> alpha (last component) == 1.0
+                assert r["color"][3] == 1.0