nt25 0.1.6__tar.gz → 0.1.8__tar.gz

{nt25-0.1.6 → nt25-0.1.8}/.gitignore

@@ -17,9 +17,10 @@ uv.lock
 ds/
 
 # output
+out.csv
 output/
 
-# others
-tests/*.jpg
-tests/*.png
+# test
+tests/**/*.jpg
+tests/**/*.png
 

{nt25-0.1.6 → nt25-0.1.8}/PKG-INFO

@@ -1,13 +1,15 @@
 Metadata-Version: 2.4
 Name: nt25
-Version: 0.1.6
+Version: 0.1.8
 Summary: Neo's Tools of Python
 Requires-Python: >=3.10
 Requires-Dist: exif>=1.6.1
 Requires-Dist: matplotlib>=3.10.6
 Requires-Dist: openpyxl>=3.1.5
 Requires-Dist: pandas>=2.3.2
+Requires-Dist: pillow>=11.3.0
 Requires-Dist: pyinstaller>=6.15.0
+Requires-Dist: requests>=2.32.5
 Requires-Dist: scikit-learn>=1.7.1
 Requires-Dist: sympy>=1.14.0
 Description-Content-Type: text/markdown
@@ -22,10 +24,10 @@ Neo's Tools of Python in 2025
 - [x] calc
 - [x] draw
 - [x] et: EXIF tools
+- [x] mt: MapXYZ Transfer tool
+- [x] ttp: TIFF to PNG, thread support
 - [ ] mysql
 - [ ] redis
-- [ ] maptrans
-- [ ] ttp
 
 ## scripts from init
 

{nt25-0.1.6 → nt25-0.1.8}/README.md

@@ -8,10 +8,10 @@ Neo's Tools of Python in 2025
 - [x] calc
 - [x] draw
 - [x] et: EXIF tools
+- [x] mt: MapXYZ Transfer tool
+- [x] ttp: TIFF to PNG, thread support
 - [ ] mysql
 - [ ] redis
-- [ ] maptrans
-- [ ] ttp
 
 ## scripts from init
 

{nt25-0.1.6 → nt25-0.1.8}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "nt25"
-version = "0.1.6"
+version = "0.1.8"
 description = "Neo's Tools of Python"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -12,11 +12,15 @@ dependencies = [
     "openpyxl>=3.1.5",
     "scikit-learn>=1.7.1",
     "sympy>=1.14.0",
+    "pillow>=11.3.0",
+    "requests>=2.32.5",
 ]
 
 [project.scripts]
 demo = "nt25.demo:main"
 et = "nt25.lib.et:main"
+mt = "nt25.mt:main"
+ttp = "nt25.ttp:main"
 
 [build-system]
 requires = ["hatchling"]

{nt25-0.1.6 → nt25-0.1.8}/src/nt25/lib/et.py

@@ -1,14 +1,16 @@
-import io
-from operator import length_hint
+import os
 import time
 import json
 import struct
 import argparse
 
+from PIL import Image as pi
+
 from datetime import UTC, datetime, timedelta, timezone
 from exif import Image, DATETIME_STR_FORMAT
 
-VERSION = "0.1.2"
+VERSION = "0.1.4"
+MAX_WIDTH = 1080
 COMMENT_SEGMENT = b"\xff\xfe"
 EPOCH = datetime.fromtimestamp(0, UTC)
 
@@ -32,6 +34,27 @@ def gpsDt2Dt(date, time, offset=8):
   return utc.astimezone(timezone(timedelta(hours=offset)))
 
 
+def optimizeFile(file, q=80, mw=MAX_WIDTH):
+  less = False
+  ofile = file + '.jpg'
+
+  img = pi.open(file)
+  w, h = img.size
+  scale = mw / max(w, h)
+  w = int(scale * w)
+  h = int(scale * h)
+  img.resize((w, h)).save(ofile, quality=q, optimize=True, progression=True)
+
+  if os.path.getsize(ofile) < os.path.getsize(file) * 0.8:
+    less = True
+    transplant(file, ofile)
+    os.replace(ofile, file)
+  else:
+    os.remove(ofile)
+
+  return less
+
+
 def tryGet(img, key, default):
   value = default
 
@@ -43,9 +66,12 @@ def tryGet(img, key, default):
   return value
 
 
-def dumpExif(file):
+def dumpExif(file, optimize=False):
   result = {}
 
+  if optimize:
+    optimizeFile(file)
+
   with open(file, 'rb') as f:
     img = Image(f)
     for key in img.get_all():
@@ -57,58 +83,74 @@ def dumpExif(file):
   return result
 
 
-def parseExif(file):
+def parseExif(file, optimize=False):
+  if optimize:
+    optimizeFile(file)
+
   with open(file, 'rb') as f:
     try:
       img = Image(f)
     except Exception:
       return {}
 
-    width = tryGet(img, 'pixel_x_dimension', -1)
-    height = tryGet(img, 'pixel_y_dimension', -1)
+  width = tryGet(img, 'pixel_x_dimension', -1)
+  height = tryGet(img, 'pixel_y_dimension', -1)
+
+  if width < 0:
+    width = tryGet(img, 'image_width', -1)
+    height = tryGet(img, 'image_height', -1)
+
+  create = tryGet(img, 'datetime_original', None)
+  modify = tryGet(img, 'datetime', None)
 
-    if width < 0:
-      width = tryGet(img, 'image_width', -1)
-      height = tryGet(img, 'image_height', -1)
+  createDt = None if create is None else dtFormatter(create)
+  modifyDt = None if modify is None else dtFormatter(modify)
 
-    create = tryGet(img, 'datetime_original', None)
-    modify = tryGet(img, 'datetime', None)
+  latitude = tryGet(img, 'gps_latitude', None)
+  latitude = None if latitude is None else dms2dec(latitude)
 
-    createDt = None if create is None else dtFormatter(create)
-    modifyDt = None if modify is None else dtFormatter(modify)
+  latRef = tryGet(img, "gps_latitude_ref", default='N')
+  if latRef != 'N' and latitude:
+    latitude = -latitude
 
-    latitude = tryGet(img, 'gps_latitude', None)
-    latitude = None if latitude is None else dms2dec(latitude)
+  longitude = tryGet(img, 'gps_longitude', None)
+  longitude = None if longitude is None else dms2dec(longitude)
 
-    longitude = tryGet(img, 'gps_longitude', None)
-    longitude = None if longitude is None else dms2dec(longitude)
+  longRef = tryGet(img, "gps_longitude_ref", default='E')
+  if longRef != 'E' and longitude:
+    longitude = -longitude
 
-    gpsDatetime = None
-    gd = tryGet(img, 'gps_datestamp', None)
-    gt = tryGet(img, 'gps_timestamp', None)
+  gpsDatetime = None
+  gd = tryGet(img, 'gps_datestamp', None)
+  gt = tryGet(img, 'gps_timestamp', None)
 
-    if gd and gt:
-      offset = int(time.localtime().tm_gmtoff / 3600)
-      gpsDatetime = gpsDt2Dt(gd, gt, offset=offset)
+  if gd and gt:
+    offset = int(time.localtime().tm_gmtoff / 3600)
+    gpsDatetime = gpsDt2Dt(gd, gt, offset=offset)
 
-    ts = -1 if createDt is None else int(createDt.timestamp())
-    mTs = -1 if modifyDt is None else int(modifyDt.timestamp())
-    gpsTs = -1 if gpsDatetime is None else int(gpsDatetime.timestamp())
+  ts = -1 if createDt is None else int(createDt.timestamp())
+  mTs = -1 if modifyDt is None else int(modifyDt.timestamp())
+  gpsTs = -1 if gpsDatetime is None else int(gpsDatetime.timestamp())
+
+  if ts > 0:
     offset = max(mTs, gpsTs) - ts
-    offsetDelta = datetime.fromtimestamp(offset, UTC) - EPOCH
-
-    return {
-        "width": width,
-        "height": height,
-        "latitude": latitude,
-        "longitude": longitude,
-        "datetime.create": dt2str(createDt),
-        "datetime.modify": dt2str(modifyDt),
-        "datetime.gps": dt2str(gpsDatetime),
-        "ts": ts,
-        "offset": offset,
-        "offset.delta": str(offsetDelta),
-    }
+    offsetDelta = str(datetime.fromtimestamp(offset, UTC) - EPOCH)
+  else:
+    offset = None
+    offsetDelta = None
+
+  return {
+      "width": width,
+      "height": height,
+      "latitude": latitude,
+      "longitude": longitude,
+      "datetime.create": dt2str(createDt),
+      "datetime.modify": dt2str(modifyDt),
+      "datetime.gps": dt2str(gpsDatetime),
+      "ts": ts,
+      "offset": offset,
+      "offset.delta": offsetDelta,
+  }
 
 
 class InvalidImageDataError(ValueError):
@@ -174,7 +216,7 @@ def getExif(segments):
     if seg[0:2] == b"\xff\xe1" and seg[4:10] == b"Exif\x00\x00":
       return seg
 
-  return None
+  return b""
 
 
 def mergeSegments(segments, exif=b""):
@@ -210,49 +252,29 @@ def mergeSegments(segments, exif=b""):
   return b"".join(segments)
 
 
-def removeExif(src, new_file=None):
-  output_is_file = False
-  if src[0:2] == b"\xff\xd8":
-    src_data = src
-    file_type = "jpeg"
-  else:
-    with open(src, 'rb') as f:
-      src_data = f.read()
-    output_is_file = True
-    if src_data[0:2] == b"\xff\xd8":
-      file_type = "jpeg"
-
-  if file_type == "jpeg":
-    segments = genSegments(src_data)
-    segments = list(filter(lambda seg: not (seg[0:2] == b"\xff\xe1"
-                                            and seg[4:10] == b"Exif\x00\x00"),
-                           segments))
-
-    segments = setComment(segments, "nt25.et")
-    new_data = b"".join(segments)
-
-  if isinstance(new_file, io.BytesIO):
-    new_file.write(new_data)
-    new_file.seek(0)
-  elif new_file:
-    with open(new_file, "wb+") as f:
-      f.write(new_data)
-  elif output_is_file:
-    with open(src, "wb+") as f:
-      f.write(new_data)
-  else:
-    raise ValueError("Give a second argument to 'remove' to output file")
+def removeExif(src, optimize=False):
+  if optimize:
+    optimizeFile(src)
 
+  with open(src, 'rb') as f:
+    src_data = f.read()
 
-def transplant(exif_src, image, new_file=None):
-  """
-  py:function:: piexif.transplant(filename1, filename2)
+  segments = genSegments(src_data)
+  segments = list(filter(lambda seg: not (seg[0:2] == b"\xff\xe1"
+                                          and seg[4:10] == b"Exif\x00\x00"),
+                         segments))
 
-  Transplant exif from filename1 to filename2.
+  segments = setComment(segments, "nt25.et")
+  new_data = b"".join(segments)
+
+  with open(src, "wb+") as f:
+    f.write(new_data)
+
+
+def transplant(exif_src, image, optimize=False):
+  if optimize:
+    optimizeFile(image)
 
-  :param str filename1: JPEG
-  :param str filename2: JPEG
-  """
   if exif_src[0:2] == b"\xff\xd8":
     src_data = exif_src
   else:
@@ -262,41 +284,29 @@ def transplant(exif_src, image, new_file=None):
   segments = genSegments(src_data)
   exif = getExif(segments)
 
-  if exif is None:
-    raise ValueError("not found exif in input")
-
-  output_file = False
-  if image[0:2] == b"\xff\xd8":
-    image_data = image
-  else:
-    with open(image, 'rb') as f:
-      image_data = f.read()
-    output_file = True
+  with open(image, 'rb') as f:
+    image_data = f.read()
 
   segments = genSegments(image_data)
   segments = setComment(segments, "nt25.et")
   new_data = mergeSegments(segments, exif)
 
-  if isinstance(new_file, io.BytesIO):
-    new_file.write(new_data)
-    new_file.seek(0)
-  elif new_file:
-    with open(new_file, "wb+") as f:
-      f.write(new_data)
-  elif output_file:
-    with open(image, "wb+") as f:
-      f.write(new_data)
-  else:
-    raise ValueError("Give a 3rd argument to 'transplant' to output file")
+  with open(image, "wb+") as f:
+    f.write(new_data)
 
 
 def main():
   parser = argparse.ArgumentParser(description="EXIF tool")
-  parser.add_argument('-v', '--version',
-                      help='echo version', action='store_true')
-  parser.add_argument('-d', '--dump', help='dump meta', action='store_true')
-  parser.add_argument('-r', '--rm', help='remove meta', action='store_true')
-  parser.add_argument('-c', '--copy', type=str, help='copy meta')
+  parser.add_argument('-v', '--version', action='store_true',
+                      help='echo version')
+  parser.add_argument('-o', '--optimize', action='store_true',
+                      help='optimize jpg file, work with -r, -d, -c, -f')
+  parser.add_argument('-r', '--rm', action='store_true',
+                      help='remove meta, use: -r -f FILE')
+  parser.add_argument('-d', '--dump', action='store_true',
+                      help='dump meta, use: -d -f FILE')
+  parser.add_argument('-c', '--copy', type=str,
+                      help='copy meta, use: -c SRC -f DST')
   parser.add_argument('-f', '--file', type=str, help='image file')
 
   args = parser.parse_args()
@@ -306,17 +316,20 @@ def main():
     return
 
   if args.file is None:
-    print("usage: et [-h] [-v] [-r FILE] [-c FILE] [-d] [-f FILE]")
+    print("usage: et [-h] [-v] [-o] [-f FILE] [-d -f FILE]\n"
+          "\t\t[-r -f FILE] [-c SRC -f DST]")
     return
 
+  opt = True if args.optimize else False
+
   if args.dump:
-    r = dumpExif(args.file)
+    r = dumpExif(args.file, optimize=opt)
   elif args.rm:
-    r = removeExif(args.file)
+    r = removeExif(args.file, optimize=opt)
   elif args.copy:
-    r = transplant(args.copy, args.file)
+    r = transplant(args.copy, args.file, optimize=opt)
   else:
-    r = parseExif(args.file)
+    r = parseExif(args.file, optimize=opt)
 
   if r is not None:
     print(json.dumps(r, indent=2, sort_keys=False))

nt25-0.1.8/src/nt25/mt.py

@@ -0,0 +1,105 @@
+from nt25 import fio
+
+import json
+import requests
+import argparse
+
+
+kEncoding = 'gbk'
+kWGSName = 'WGS-84'
+
+kMaxTranCount = 50
+
+kWGSCode = 4326
+k50NCode = 32650
+kCGS2000Z20Code = 4498
+kCGS2000Z21Code = 4499
+
+kURLFormatter = 'https://api.maptiler.com/coordinates/transform/' + \
+    '{cs}.json?key={key}&s_srs={s}&t_srs={t}'
+
+
+def genCs4Tran(coordinates):
+  cs = []
+
+  for i in range(min(len(coordinates), kMaxTranCount)):
+    c = coordinates[i]
+    cs.append('{0},{1}'.format(c[0], c[1]))
+
+  return ';'.join(cs)
+
+
+def fetchResult(url):
+  result = {}
+  res = requests.get(url)
+
+  try:
+    result = json.loads(res.text)
+  except Exception as e:
+    print(e, '\n\t', res.text)
+
+  return result
+
+
+def transform(key, coordinates, startCode, toCode):
+  results = []
+
+  cc = [coordinates[i:i + kMaxTranCount]
+        for i in range(0, len(coordinates), kMaxTranCount)]
+
+  for c in cc:
+    url = kURLFormatter.format(cs=genCs4Tran(c),
+                               key=key, s=startCode, t=toCode)
+    result = fetchResult(url)
+
+    if result and result['results'] and result['results'][0]['x'] is not None:
+      results.extend(result['results'])
+
+  for i in range(len(results)):
+    results[i]['z'] = coordinates[i][2] if len(coordinates[i]) > 2 else 0
+
+  return results
+
+
+def main():
+  parse = argparse.ArgumentParser(description='Map Transform tool, '
+                                  'from https://docs.maptiler.com/cloud'
+                                  '/api/coordinates/#transform-coordinates')
+
+  #  default=kKey, required=False)
+  parse.add_argument('-k', '--key', type=str,
+                     help='MapTiler key', required=True)
+  parse.add_argument('-i', '--input', type=str, required=True,
+                     help='input file')
+  parse.add_argument('-o', '--output', type=str, help='output file',
+                     default='out.csv')
+  parse.add_argument('-s', '--start', type=str, default='4498',
+                     help='transform start code')
+  parse.add_argument('-t', '--to', type=str, default='4236',
+                     help='transform code to')
+
+  args = parse.parse_args()
+
+  key = args.key
+  input = args.input
+  output = args.output
+  start = args.start
+  to = args.to
+
+  csv = fio.getCSV(input, width=3, startLine=1)
+
+  if csv is not None:
+    coordinates = []
+    for i in range(len(csv[0])):
+      coordinates.append((csv[0][i], csv[1][i], csv[2][i]))
+
+    result = transform(key, coordinates, start, to)
+
+    if len(result) > 0:
+      content = list(map(lambda r: (r['x'], r['y'], r['z']),  result))
+      fio.saveCSV(content, output, colsInline=False)
+      print(f'Saved {len(result)} rows in {output}')
+
+
+if __name__ == '__main__':
+  main()

nt25-0.1.8/src/nt25/ttp.py

@@ -0,0 +1,201 @@
+import re
+import os
+import glob
+import argparse
+import time
+
+from threading import Thread, Lock
+from multiprocessing import cpu_count
+
+from PIL import Image
+import numpy as np
+import matplotlib.colors as mcolors
+
+gTLock = Lock()
+gForceQuit = False
+
+gMaxValue = 0
+gShadowValue = 0
+
+gCrop = None
+gArea = None
+gLast = None
+gColors = None
+
+kTifLevel = 255
+
+
+def nsort(s):
+  sub = re.split(r'(\d+)', s)
+  sub = [int(c) if c.isdigit() else c for c in sub]
+  return sub
+
+
+def genGradColors(gradStart, gradStop):
+  # ks = kTifLevel * kTifLevel
+  # yc = np.linspace(mcolors.to_rgba(gradStart),
+  #                  mcolors.to_rgba(gradStop), ks) * ks
+  # colors = [yc[ks - (i - kTifLevel) * (i - kTifLevel)]
+  #           for i in range(0, kTifLevel)]
+
+  colors = np.linspace(mcolors.to_rgba(gradStart),
+                       mcolors.to_rgba(gradStop), kTifLevel) * kTifLevel
+  return np.vstack([[0, 0, 0, 0], colors]).astype(np.uint8)
+
+
+def splitArray(array, times):
+  chunk = len(array) // times
+  left = len(array) % times
+
+  result = []
+  for i in range(times):
+    start = i * chunk + min(i, left)
+    end = start + chunk + (1 if i < left else 0)
+    result.append(array[start:end])
+
+  return result
+
+
+def dump(array):
+  shp = array.shape
+  for i in range(shp[0]):
+    print(array[i])
+
+
+def ttp(array, path, maxValue):
+  global gTLock, gForceQuit, gCrop, gArea, gColors, gMaxValue, gLast
+
+  if gCrop is None or gArea is None or gColors is None:
+    return
+
+  for tif in array:
+    name = os.path.splitext(os.path.basename(tif))[0]
+    out = os.path.join(path, name + '.png')
+
+    image = Image.open(tif)
+    ta = np.array(image)
+    ta = ta[gCrop[0]:gCrop[1], gCrop[2]:gCrop[3]]
+
+    ta[ta < 0] = 0
+
+    with gTLock:
+      if ta.max() > gMaxValue:
+        gMaxValue = ta.max()
+
+      if gShadowValue > 0:
+        leap = maxValue / 40
+        ta = np.where(np.logical_and(gArea > 0, ta < gShadowValue),
+                      gShadowValue, ta)
+        ta = np.where(gLast > ta + leap, gLast - leap, ta)
+        gLast = np.array(ta)
+        gArea = np.where(ta > gShadowValue, 1, gArea)
+
+    ta[ta > maxValue] = maxValue
+    ta = ta / maxValue * kTifLevel
+    Image.fromarray(gColors[ta.astype(np.uint8)], mode='RGBA').save(out)
+
+    if gForceQuit:
+      break
+    else:
+      print('.', end='', flush=True)
+
+
+def main():
+  global gForceQuit, gCrop, gArea, gColors, gMaxValue, gLast
+
+  threadCounts = int(cpu_count() / 2)
+
+  parser = argparse.ArgumentParser(description="TIFF -> PNG")
+  parser.add_argument('-d', '--dir', help='Directory to handle',
+                      default='.', type=str, required=False,)
+  parser.add_argument('-s', '--gradStart', help='Gradient color to Start',
+                      default='#00FFFF', type=str, required=False,)
+  parser.add_argument('-t', '--gradStop', help='Gradient color to Stop',
+                      default='#00008B', type=str, required=False,)
+  parser.add_argument('--TB', help='Crop TIFF from Top to Bottom', nargs='+',
+                      # default=[1700, 3000], type=int, required=False,)
+                      # default=[1350, 4250], type=int, required=False,)
+                      default=[1400, 3550], type=int, required=False,)
+  # default=[2890, 2895], type=int, required=False,)
+  parser.add_argument('--LR', help='Crop TIFF from Left to Right', nargs='+',
+                      default=[750, 2300], type=int, required=False,)
+  # default=[1650, 1655], type=int, required=False,)
+  parser.add_argument('-m', '--maxValue', help='Map Max Value',
+                      default=16, type=int, required=False,)
+  parser.add_argument('-v', '--shadowValue', help='keep Value in Shadow',
+                      default=1, type=int, required=False,)
+  parser.add_argument('-c', '--threadCounts', help='Minimum number of Threads',
+                      default=threadCounts, type=int, required=False,)
+
+  args = parser.parse_args()
+  folder = args.dir
+  gradStart = args.gradStart
+  gradStop = args.gradStop
+
+  gColors = genGradColors(gradStart, gradStop)
+
+  TB = args.TB
+  LR = args.LR
+  gCrop = [TB[0], TB[1], LR[0], LR[1]]
+  gArea = np.zeros([TB[1] - TB[0], LR[1] - LR[0]], dtype=np.uint8)
+  gLast = np.zeros([TB[1] - TB[0], LR[1] - LR[0]])
+
+  maxValue = args.maxValue
+  threadCounts = args.threadCounts
+
+  gShadowValue = args.shadowValue
+
+  if gShadowValue > 0:
+    print(f'Shadow Value: {gShadowValue}')
+    threadCounts = 1
+
+  if threadCounts > 1:
+    print(f'Multi-threads to work: {threadCounts}T')
+
+  files = glob.glob(os.path.join(folder, '*.tif'))
+  files = sorted(files, key=nsort)
+
+  if len(files) == 0:
+    print("no TIF found")
+    return
+
+  path = os.path.join(folder, 'out')
+  if not os.path.exists(path):
+    os.makedirs(path)
+
+  tfs = splitArray(files, threadCounts)
+
+  td = []
+  for tif in tfs:
+    if tif is not None and len(tif) > 0:
+      t = Thread(target=ttp, args=(tif, path, maxValue,))
+      t.daemon = True
+      t.start()
+      td.append(t)
+
+  while True:
+    working = False
+    for t in td:
+      if t.is_alive():
+        working = True
+        break
+
+    if working:
+      try:
+        time.sleep(0.5)
+      except KeyboardInterrupt:
+        if not gForceQuit:
+          print("\n> WARN: Trying to terminate threads...")
+
+        gForceQuit = True
+    else:
+      break
+
+  if gForceQuit:
+    print("> WARN: Force quit!")
+  else:
+    print(f"\nTotal Max value: {maxValue}/{gMaxValue:.2f}")
+
+
+if __name__ == '__main__':
+  main()

nt25-0.1.8/tests/mt.csv

@@ -0,0 +1,3 @@
+X,Y,H
+20510210.743588,4058386.735392,155.55
+20510196.183790,4057723.195846,123.45