pylineament 0.1.0__tar.gz → 0.1.1__tar.gz

{pylineament-0.1.0 → pylineament-0.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pylineament
-Version: 0.1.0
+Version: 0.1.1
 Summary: Python Geological Lineament extraction package
 Author-email: Epo Kusumah <epo.pk@universiaspertamina.ac.id>
 License-Expression: MIT

pylineament-0.1.1/pylineament/__init__.py

@@ -0,0 +1,30 @@
+from .pylineament import (
+    read_raster,
+    reduce_lines,
+    extract_lineament_points,
+    convert_points_to_line,
+    hillshade,
+    image_splitting,
+    merge_lines_csv_to_shp,
+    merge_single_csv_to_shp,
+    raster_resize,
+    dem_to_line,
+    dem_to_shp,
+    dem_to_shp_small
+
+)
+
+__all__ = [
+    "read_raster",
+    "reduce_lines",
+    "extract_lineament_points",
+    "convert_points_to_line",
+    "hillshade",
+    "image_splitting",
+    "merge_lines_csv_to_shp",
+    "merge_single_csv_to_shp",
+    "raster_resize",
+    "dem_to_line",
+    "dem_to_shp",
+    "dem_to_shp_small"
+]

{pylineament-0.1.0 → pylineament-0.1.1}/pylineament/pylineament.py

@@ -9,7 +9,27 @@ import rasterio
 
 
 def read_raster(im_path, split_size=500):
-
+    """
+    Read and process a raster image (e.g., DEM).
+
+    Parameters
+    ----------
+    im_path : str
+        Path to the input raster file.
+    split_size : int, optional
+        Block size for splitting large rasters during processing (default is 500).
+
+    Returns
+    -------
+    imageSplitting : pandas.DataFrame
+        image subset coordinate and array slicing.
+    dem : numpy.ndarray
+        Digital Elevation Model array.
+    extent : tuple
+        Spatial extent of the raster (left, bottom, right, yop).
+    crs_espg : int
+        EPSG code of the raster’s coordinate reference system.
+    """
     img_format = os.path.split(im_path)[-1].split('.')[-1]
 
     im_path = os.path.abspath(im_path)
@@ -64,21 +84,48 @@ def read_raster(im_path, split_size=500):
     resYs = [resY]*len(grids)
     szs   = [sz]*len(grids)
 
-    df = pd.DataFrame(zip(ns, lefts, tops, resXs, resYs, szs), columns=['ns', 'lefts', 'tops', 'resXs', 'resYs', 'szs'])
+    imageSplitting = pd.DataFrame(zip(ns, lefts, tops, resXs, resYs, szs), columns=['ns', 'lefts', 'tops', 'resXs', 'resYs', 'szs'])
     
-    df[['L', 'R', 'B', 'T']] = grids
+    imageSplitting[['L', 'R', 'B', 'T']] = grids
 
-    df['left_bound']    = df['lefts'] + df['L']*df['resXs']
-    df['bottom_bound']    = df['tops'] - df['T']*df['resYs']
-    df['right_bound']    = df['left_bound'] + abs(df['L'] - df['R'])*df['resXs']
-    df['top_bound']    = df['bottom_bound'] + abs(df['T'] - df['B'])*df['resYs']
+    imageSplitting['left_bound']    = imageSplitting['lefts'] + imageSplitting['L']*imageSplitting['resXs']
+    imageSplitting['bottom_bound']    = imageSplitting['tops'] - imageSplitting['T']*imageSplitting['resYs']
+    imageSplitting['right_bound']    = imageSplitting['left_bound'] + abs(imageSplitting['L'] - imageSplitting['R'])*imageSplitting['resXs']
+    imageSplitting['top_bound']    = imageSplitting['bottom_bound'] + abs(imageSplitting['T'] - imageSplitting['B'])*imageSplitting['resYs']
 
     dem = im 
 
-    return df, dem, extent,crs_espg
+    return imageSplitting, dem, extent,crs_espg
 
 
 def reduce_lines(lines, extent, dem_shape, min_dist=10, seg_len=10):
+
+    """
+    Simplify and merge extracted line segments to reduce redundancy.
+    Parameters
+    ----------
+    lines : dataframes
+        Extracted line segments.
+    extent : tuple
+        Raster extent used for spatial reference L B R T.
+    dem_shape : tuple
+        Shape of the DEM (rows, columns).
+    min_dist : float, optional
+        Minimum allowed distance between lines before merging (default is 10).
+    seg_len : float, optional
+        Minimum segment length to retain (default is 10).
+
+    Returns
+    -------
+    initial_lines : list
+        Original extracted lines.
+    broken_lines_ : list
+        Split or fragmented lines before reduction.
+    reduced_lines : list
+        Final reduced set of merged lineaments.
+    """
+
+
     # frag lines
 
     d  = np.sqrt((lines['max_x'] - lines['min_x'])**2 + (lines['max_y'] - lines['min_y'])**2)
@@ -112,21 +159,21 @@ def reduce_lines(lines, extent, dem_shape, min_dist=10, seg_len=10):
             df_[['quad', 'group', 'min_x', 'max_x', 'min_y', 'max_y', 'dr_dx', 'coef', 'intercept']] = azi, clust, xmin, xmax, ymin, ymax, dr_dx, coef, intercept
             container.append(df_)
             
-    broken_lines = pd.concat(container)
+    initial_lines = pd.concat(container)
 
-    if len(broken_lines)>10:
+    if len(initial_lines)>10:
 
         from sklearn.neighbors import KDTree
         
-        tree= KDTree(broken_lines[['xs_a', 'xs_b', 'ys_a', 'ys_b']])
-        dist, idxs = tree.query(broken_lines[['xs_a', 'xs_b', 'ys_a', 'ys_b']], k=10, return_distance=True)
+        tree= KDTree(initial_lines[['xs_a', 'xs_b', 'ys_a', 'ys_b']])
+        dist, idxs = tree.query(initial_lines[['xs_a', 'xs_b', 'ys_a', 'ys_b']], k=10, return_distance=True)
         idxs = np.where(dist>min_dist,dist.shape[0]+1,idxs)
 
         keepit = np.unique(np.sort(idxs, axis=1)[:,0])
-        broken_lines_ = broken_lines.iloc[keepit]
+        broken_lines_ = initial_lines.iloc[keepit]
         # broken_lines_ = broken_lines.iloc[keepit].drop_duplicates(['azi', 'clust'])
     else:
-        broken_lines_ = broken_lines
+        broken_lines_ = initial_lines
 
     
     container = []
@@ -145,28 +192,52 @@ def reduce_lines(lines, extent, dem_shape, min_dist=10, seg_len=10):
             deg    = -np.degrees(np.arctan((max_y_ - min_y_) / (max_x_ - min_x_)))+90
             container.append([quad, group, min_x_, max_x_, min_y_, max_y_, L, deg])
             
-    broken_lines__ = pd.DataFrame(container, columns=['quad', 'group', 'min_x', 'max_x', 'min_y', 'max_y', 'L', 'deg'])
+    reduced_lines = pd.DataFrame(container, columns=['quad', 'group', 'min_x', 'max_x', 'min_y', 'max_y', 'L', 'deg'])
 
     left, right, top, bot = extent
     
-    broken_lines__['min_x_'] = broken_lines__['min_x']
-    broken_lines__['max_x_'] = broken_lines__['max_x']
+    reduced_lines['min_x_'] = reduced_lines['min_x']
+    reduced_lines['max_x_'] = reduced_lines['max_x']
 
-    broken_lines__['min_y_'] = broken_lines__['min_y']
-    broken_lines__['max_y_'] = broken_lines__['max_y']
+    reduced_lines['min_y_'] = reduced_lines['min_y']
+    reduced_lines['max_y_'] = reduced_lines['max_y']
 
 
-    broken_lines__['min_x'] = (broken_lines__['min_x']/dem_shape[1])*(right - left) + left
-    broken_lines__['max_x'] = (broken_lines__['max_x']/dem_shape[1])*(right - left) + left
+    reduced_lines['min_x'] = (reduced_lines['min_x']/dem_shape[1])*(right - left) + left
+    reduced_lines['max_x'] = (reduced_lines['max_x']/dem_shape[1])*(right - left) + left
 
-    broken_lines__['min_y'] = -(broken_lines__['min_y']/dem_shape[0])*(bot - top) + bot
-    broken_lines__['max_y'] = -(broken_lines__['max_y']/dem_shape[0])*(bot - top) + bot
-    broken_lines__['length'] = (broken_lines__['max_x'] - broken_lines__['min_x'])**2 + (broken_lines__['max_y'] - broken_lines__['min_y'])**2
+    reduced_lines['min_y'] = -(reduced_lines['min_y']/dem_shape[0])*(bot - top) + bot
+    reduced_lines['max_y'] = -(reduced_lines['max_y']/dem_shape[0])*(bot - top) + bot
+    reduced_lines['length'] = np.sqrt((reduced_lines['max_x'] - reduced_lines['min_x'])**2 + (reduced_lines['max_y'] - reduced_lines['min_y'])**2)
 
-    return broken_lines, broken_lines_, broken_lines__
+    return initial_lines, broken_lines_, reduced_lines
 
 
 def extract_lineament_points(dem, eps=1.2, thresh=40,z_multip=1):
+    """
+    Detect edge points representing potential lineaments from a DEM.
+
+    Parameters
+    ----------
+    dem : numpy.ndarray
+        Input Digital Elevation Model.
+    eps : float, optional
+        Edge detection sensitivity parameter (default is 1.2).
+    thresh : float, optional
+        Threshold for edge classification (default is 40).
+    z_multip : float, optional
+        Vertical exaggeration factor for slope computation (default is 1).
+
+    Returns
+    -------
+    container : list
+        Container of extracted lineament points.
+    im_prewitt : numpy.ndarray
+        Image after applying Prewitt edge filter.
+    im_prewitt_clip : numpy.ndarray
+        Thresholded edge image highlighting lineament points.
+    """
+
     from sklearn.cluster import DBSCAN
     # import rasterio
     from skimage.filters import prewitt
@@ -227,6 +298,21 @@ def extract_lineament_points(dem, eps=1.2, thresh=40,z_multip=1):
 
 
 def convert_points_to_line(container):
+
+    """
+    Convert sets of edge points into connected line segments.
+
+    Parameters
+    ----------
+    container : list
+        Extracted lineament points grouped by proximity.
+
+    Returns
+    -------
+    lines : dataFrame
+        Line geometries derived from point clusters.
+    """
+
     from sklearn.linear_model import LinearRegression
 
     if len(container)>0:
@@ -264,6 +350,26 @@ def convert_points_to_line(container):
 
 
 def hillshade(array, azimuth=315, angle_altitude=45, z_multip=1):
+    """
+    Generate a hillshade image from a DEM for enhanced visualization.
+
+    Parameters
+    ----------
+    array : numpy.ndarray
+        DEM array.
+    azimuth : float, optional
+        Illumination azimuth in degrees (default is 315).
+    angle_altitude : float, optional
+        Illumination altitude angle in degrees (default is 45).
+    z_multip : float, optional
+        Vertical exaggeration multiplier (default is 1).
+
+    Returns
+    -------
+    hs : numpy.ndarray
+        Hillshaded representation of the DEM.
+    """
+
     array = array*z_multip
     azimuth = 360.0 - azimuth  # Convert azimuth to geographic convention
     x, y = np.gradient(array)
@@ -273,11 +379,33 @@ def hillshade(array, azimuth=315, angle_altitude=45, z_multip=1):
     alt_rad = angle_altitude * np.pi / 180.  # Convert altitude to radians
 
     shaded = np.sin(alt_rad) * np.sin(slope) + np.cos(alt_rad) * np.cos(slope) * np.cos((azm_rad - np.pi / 2.) - aspect)
+    hs = 255 * (shaded + 1) / 2  # Scale to 0-255
+
+
     
-    return 255 * (shaded + 1) / 2  # Scale to 0-255
+    return hs
 
 
 def image_splitting(im_path='srtm/srtm_java.tif', split_size=500, tempfolder='temp'):
+    
+    """
+    Split a large image or DEM into smaller tiles for efficient processing.
+
+    Parameters
+    ----------
+    im_path : str, optional
+        Path to the input raster file (default is 'srtm/srtm_java.tif').
+    split_size : int, optional
+        Tile size in pixels (default is 500).
+    tempfolder : str, optional
+        Temporary folder for saving image tiles (default is 'temp').
+
+    Returns
+    -------
+    imageBoundaries : dataFrame
+        List of boundaries or filenames for generated image tiles.
+    """
+    
     import pandas as pd 
     import numpy as np
     import rasterio
@@ -332,14 +460,14 @@ def image_splitting(im_path='srtm/srtm_java.tif', split_size=500, tempfolder='te
     resYs = [resY]*len(grids)
     szs   = [sz]*len(grids)
 
-    df = pd.DataFrame(zip(ns, target_folders, lefts, tops, resXs, resYs, szs), columns=['ns', 'target_folders', 'lefts', 'tops', 'resXs', 'resYs', 'szs'])
+    imageBoundaries = pd.DataFrame(zip(ns, target_folders, lefts, tops, resXs, resYs, szs), columns=['ns', 'target_folders', 'lefts', 'tops', 'resXs', 'resYs', 'szs'])
     
-    df[['L', 'R', 'B', 'T']] = grids
+    imageBoundaries[['L', 'R', 'B', 'T']] = grids
 
-    for n, tempfolder, left, top, resX, resY, sz, L, R, B, T in df.values:
+    for n, tempfolder, left, top, resX, resY, sz, L, R, B, T in imageBoundaries.values:
         l = left + L*resX
         # b = top - T*resY - sz*resY
-        b = -top - T*resY
+        b = top - T*resY
 
         transform = rasterio.Affine.translation(l - resX / 2, b - resY / 2) * rasterio.Affine.scale(resX, resY)
 
@@ -360,26 +488,43 @@ def image_splitting(im_path='srtm/srtm_java.tif', split_size=500, tempfolder='te
         new_dataset.write(Z, 1)
         new_dataset.close()
 
-    df['left_bound']    = df['lefts'] + df['L']*df['resXs']
-    df['bottom_bound']    = df['tops'] - df['T']*df['resYs']
-    df['right_bound']    = df['left_bound'] + abs(df['L'] - df['R'])*df['resXs']
-    df['top_bound']    = df['bottom_bound'] + abs(df['T'] - df['B'])*df['resYs']
+    imageBoundaries['left_bound']    = imageBoundaries['lefts'] + imageBoundaries['L']*imageBoundaries['resXs']
+    imageBoundaries['bottom_bound']    = imageBoundaries['tops'] - imageBoundaries['T']*imageBoundaries['resYs']
+    imageBoundaries['right_bound']    = imageBoundaries['left_bound'] + abs(imageBoundaries['L'] - imageBoundaries['R'])*imageBoundaries['resXs']
+    imageBoundaries['top_bound']    = imageBoundaries['bottom_bound'] + abs(imageBoundaries['T'] - imageBoundaries['B'])*imageBoundaries['resYs']
 
-    return df
+    return imageBoundaries
 
 
 def merge_lines_csv_to_shp(tempfolder, shppath, save_to_file):
-    
+    """
+    Merge multiple lineament CSV outputs into a single shapefile.
+
+    Parameters
+    ----------
+    tempfolder : str
+        Directory containing intermediate CSV line data.
+    shppath : str
+        Path to the base shapefile used for spatial reference.
+    save_to_file : str
+        Output shapefile path.
+
+    Returns
+    -------
+    lines : Dataframe
+        Combined lineament data as a Dataframe.
+    """
+
     flist = glob.glob(f'{tempfolder}/*.csv')
 
-    dfs = [pd.read_csv(f) for f in flist]
+    all_lines = [pd.read_csv(f) for f in flist]
 
-    df = pd.concat(dfs).reset_index(drop=True)
-    df = df[['quad', 'group', 'min_x', 'max_x', 'min_y', 'max_y', 'L', 'deg', 'length', 'crs']]
+    lines = pd.concat(all_lines).reset_index(drop=True)
+    lines = lines[['quad', 'group', 'min_x', 'max_x', 'min_y', 'max_y', 'L', 'deg', 'length', 'crs']]
 
     if save_to_file==True:
             
-        crs_espg = df['crs'].values[0]
+        crs_espg = lines['crs'].values[0]
 
         if type(crs_espg) != int:
             crs_espg = 4326
@@ -410,7 +555,7 @@ def merge_lines_csv_to_shp(tempfolder, shppath, save_to_file):
         lineShp = fiona.open(shppath, mode='w', driver='ESRI Shapefile',
                 schema = schema, crs = crs_espg)
 
-        for quad, group,min_x, max_x, min_y, max_y, L_px,  deg, L_crs, crs in df.values:
+        for quad, group,min_x, max_x, min_y, max_y, L_px,  deg, L_crs, crs in lines.values:
             g = ([(min_x, min_y), (max_x, max_y)])
             rowDict = {
             'geometry' : {'type':'LineString',
@@ -427,15 +572,34 @@ def merge_lines_csv_to_shp(tempfolder, shppath, save_to_file):
 
         lineShp.close()
 
-    return df
+    return lines
 
 
 def merge_single_csv_to_shp(fname, shppath, save_to_file):
-    df = pd.read_csv(fname)
+    """
+    Merge a single CSV lineament file into a shapefile.
+
+    Parameters
+    ----------
+    fname : str
+        Path to the CSV file containing lineament data.
+    shppath : str
+        Path to reference shapefile for coordinate system.
+    save_to_file : str
+        Output shapefile path.
 
-    df = df[['quad', 'group', 'min_x', 'max_x', 'min_y', 'max_y', 'L', 'deg', 'length', 'crs']]
+    Returns
+    -------
+    lines : dataFrame
+        Converted lineament data as shapefile.
+    """
 
-    crs_espg = df['crs'].values[0]
+
+    lines = pd.read_csv(fname)
+
+    lines = lines[['quad', 'group', 'min_x', 'max_x', 'min_y', 'max_y', 'L', 'deg', 'length', 'crs']]
+
+    crs_espg = lines['crs'].values[0]
 
     if save_to_file == True:
         
@@ -454,7 +618,7 @@ def merge_single_csv_to_shp(fname, shppath, save_to_file):
         lineShp = fiona.open(shppath, mode='w', driver='ESRI Shapefile',
                 schema = schema, crs = f"EPSG:{crs_espg}")
 
-        for quad, group,min_x, max_x, min_y, max_y, L_px,  deg, L_crs, crs in df.values:
+        for quad, group,min_x, max_x, min_y, max_y, L_px,  deg, L_crs, crs in lines.values:
             g = ([(min_x, min_y), (max_x, max_y)])
             rowDict = {
             'geometry' : {'type':'LineString',
@@ -472,10 +636,25 @@ def merge_single_csv_to_shp(fname, shppath, save_to_file):
 
         lineShp.close()
 
-    return df
+    return lines
 
 
 def raster_resize (dem, factor=1):
+    """
+    Resize or downscale a DEM array.
+
+    Parameters
+    ----------
+    dem : numpy.ndarray
+        Input DEM array.
+    factor : float, optional
+        Rescaling factor (e.g., 0.5 reduces size by half, default is 1).
+
+    Returns
+    -------
+    dem : numpy.ndarray
+        Rescaled DEM array.
+    """
 
     from skimage.transform import rescale 
 
@@ -504,7 +683,48 @@ def dem_to_line(path,
                 min_dist=10, 
                 seg_len=10,
                 z_multip=1.0,
-                downscale = 1.0):
+                downscale = 1.0,
+                save_csv = False):
+    """
+    Extract lineaments directly from a DEM and return line features.
+
+    Parameters
+    ----------
+    path : str
+        Path to input DEM file.
+    tempfolder : str, optional
+        Folder for temporary outputs (default is 'temp').
+    eps : float, optional
+        Edge detection sensitivity (default is 1.2).
+    thresh : float, optional
+        Edge threshold for filtering (default is 40).
+    min_dist : float, optional
+        Minimum distance between line segments for merging (default is 10).
+    seg_len : float, optional
+        Minimum segment length (default is 10).
+    z_multip : float, optional
+        Vertical exaggeration multiplier (default is 1.0).
+    downscale : float, optional
+        DEM downscaling factor (default is 1.0).
+    save_csv : bool, optional
+        Save intermediate line data to CSV (default is False).
+
+    Returns
+    -------
+    dem : numpy.ndarray
+        Processed DEM array.
+    extent : tuple
+        Raster extent (Left, Bottom, Right, Top).
+    lines : dataFrame
+        Extracted lineament features.
+    im_prewitt : numpy.ndarray
+        Prewitt-filtered edge image.
+    im_prewitt_clip : numpy.ndarray
+        Thresholded edge map.
+    container : list
+        Intermediate lineament point container.
+    """
+
 
     path = os.path.normpath(path)
     
@@ -522,10 +742,10 @@ def dem_to_line(path,
     if len(lines) > 0:
         _,_,lines = reduce_lines(lines, extent=extent, dem_shape=dem.shape, min_dist=min_dist, seg_len=seg_len)
         fname  = path.split('\\')[-1].split('.')[0]
-
         # fname  = path.replace('.tiff', '.csv')
         lines['crs'] = crs_espg
-        lines.to_csv(f'{tempfolder}\\{fname}.csv', index=False)
+        if save_csv:
+            lines.to_csv(f'{tempfolder}\\{fname}.csv', index=False)
         return dem, extent, lines, im_prewitt, im_prewitt_clip, container
     
     else:
@@ -533,18 +753,55 @@ def dem_to_line(path,
         return dem, extent, lines, im_prewitt, im_prewitt_clip, container
 
 
-def dem_to_line_runner(im_path, 
-                       tempfolder='temp', 
-                       shpname='test', 
-                       eps=1.2, 
-                       thresh=40, 
-                       min_dist=10, 
-                       seg_len=10, 
-                       split_size=500, 
-                       z_multip=1,
-                       downscale = 1,
-                       save_to_file=True,
-                       keep_intermediate_file = True):
+def dem_to_shp(im_path, 
+                tempfolder='temp', 
+                eps=1.2, 
+                thresh=40, 
+                min_dist=10, 
+                seg_len=10, 
+                split_size=500, 
+                z_multip=1,
+                downscale = 1,
+                shp_name = None,
+                save_to_file=True,
+                keep_intermediate_file = False,
+                n_job = -1):
+    """
+    Extract lineaments from a (large) DEM and export results as a shapefile. 
+    This will involve image splitting, and the use of parallel computing to achieve calculation efficiency.
+
+    Parameters
+    ----------
+    im_path : str
+        Path to input DEM.
+    tempfolder : str, optional
+        Folder for temporary files (default is 'temp').
+    eps : float, optional
+        Edge detection sensitivity (default is 1.2).
+    thresh : float, optional
+        Edge threshold value (default is 40).
+    min_dist : float, optional
+        Minimum distance between lines (default is 10).
+    seg_len : float, optional
+        Minimum line segment length (default is 10).
+    split_size : int, optional
+        DEM tile size for splitting (default is 500).
+    z_multip : float, optional
+        Vertical exaggeration factor (default is 1).
+    downscale : float, optional
+        Downscaling factor for DEM (default is 1).
+    shp_name : str, optional
+        Output shapefile name.
+    save_to_file : bool, optional
+        Whether to save shapefile to disk (default is True).
+    keep_intermediate_file : bool, optional
+        Retain temporary files (default is False).
+
+    Returns
+    -------
+    lines : dataFrame
+        Extracted lineament shapefile.
+    """
     
     im_path = os.path.normpath(im_path)
 
@@ -568,13 +825,20 @@ def dem_to_line_runner(im_path,
                              [min_dist]*len(flist), 
                              [seg_len]*len(flist), 
                              [z_multip]*len(flist),
-                             [downscale]*len(flist))).values
+                             [downscale]*len(flist),
+                             [True]*len(flist))).values
 
     from joblib import Parallel, delayed
-    Parallel(n_jobs=-1)(delayed(dem_to_line)(*c) for c in cases)
+    Parallel(n_jobs=n_job)(delayed(dem_to_line)(*c) for c in cases)
+
+    fname = im_path.split('\\')[-1].split('.')[0]
+    csv_name  = f'{tempfolder}\\{fname}.csv'
+    
+    if shp_name == None:
+        shp_name  = f'{fname}'
 
     df = merge_lines_csv_to_shp(tempfolder=tempfolder, 
-                                shppath=shpname, 
+                                shppath=shp_name, 
                                 save_to_file=save_to_file)
     
 
@@ -590,17 +854,51 @@ def dem_to_line_runner(im_path,
     return df
 
 
-def dem_to_line_runner_small(im_path, 
-                             tempfolder='temp', 
-                             eps=1.2, 
-                             thresh=40, 
-                             min_dist=10, 
-                             seg_len=10, 
-                             z_multip=1,
-                             downscale=1,
-                             shp_name=None, 
-                             save_to_file=True):
+def dem_to_shp_small(im_path, 
+                     tempfolder='temp', 
+                     eps=1.2, 
+                     thresh=40, 
+                     min_dist=10, 
+                     seg_len=10, 
+                     z_multip=1,
+                     downscale=1,
+                     shp_name=None, 
+                     save_to_file=True):
     
+    """
+    Extract lineaments from a (small) DEM and export results as a shapefile. 
+    The image will not splited, and be run as single chunk. This process only use single core, 
+    therefore calculation for large dataset will took very long time.
+
+    Parameters
+    ----------
+    im_path : str
+        Path to the input DEM file.
+    tempfolder : str, optional
+        Folder for temporary outputs (default is 'temp').
+    eps : float, optional
+        Edge detection sensitivity (default is 1.2).
+    thresh : float, optional
+        Edge threshold value (default is 40).
+    min_dist : float, optional
+        Minimum distance between line segments (default is 10).
+    seg_len : float, optional
+        Minimum segment length (default is 10).
+    z_multip : float, optional
+        Vertical exaggeration multiplier (default is 1).
+    downscale : float, optional
+        DEM downscaling factor (default is 1).
+    shp_name : str, optional
+        Output shapefile name.
+    save_to_file : bool, optional
+        Whether to save shapefile to disk (default is True).
+
+    Returns
+    -------
+    lines : dataFrame
+        Extracted lineament features.
+    """
+
     im_path = os.path.normpath(im_path)
     if os.path.isdir(tempfolder):
         'delete content' 
@@ -618,7 +916,8 @@ def dem_to_line_runner_small(im_path,
                                                                               min_dist=min_dist, 
                                                                               seg_len=seg_len,
                                                                               z_multip=z_multip,
-                                                                              downscale=downscale)
+                                                                              downscale=downscale,
+                                                                              save_csv=True)
     
     fname = im_path.split('\\')[-1].split('.')[0]
     csv_name  = f'{tempfolder}\\{fname}.csv'
@@ -637,5 +936,5 @@ def dem_to_line_runner_small(im_path,
         os.removedirs(tempfolder)
 
 
-    return dem, extent, lines, im_prewitt, im_prewitt_clip, container
+    return lines
 

{pylineament-0.1.0 → pylineament-0.1.1}/pylineament/pylineament_ui.py

@@ -1,34 +1,40 @@
 import sys
 import numpy as np
 import pyqtgraph as pg
-from PyQt5.QtWidgets import (QApplication, QMainWindow, QWidget, QVBoxLayout, 
-                             QPushButton, QFileDialog, 
-                             QTabWidget, QTextEdit, 
-                             QHBoxLayout, QSlider, QLabel, 
-                             QSpacerItem, QSizePolicy, QComboBox,
-                             QLineEdit, QCheckBox, QGridLayout, QProgressBar, QSplitter )
-
-from PyQt5.QtCore import QThreadPool, QRunnable, pyqtSignal, QObject
+from PyQt5.QtWidgets import (QApplication, 
+                             QMainWindow, 
+                             QWidget, 
+                             QVBoxLayout, 
+                             QPushButton, 
+                             QFileDialog, 
+                             QTabWidget,  
+                             QHBoxLayout, 
+                             QSlider, 
+                             QLabel, 
+                             QComboBox,
+                             QCheckBox, 
+                             QSplitter,
+                             QMessageBox )
+
+from PyQt5.QtCore import QThreadPool, QRunnable
 
 
 from skimage.transform import rescale
+
 from PyQt5.QtCore import Qt
+
 import numpy as np
 import pandas as pd
-from pylineament import (dem_to_line, read_raster,
+from pylineament import (dem_to_line, 
+                         read_raster,
                          extract_lineament_points,
                          convert_points_to_line,
-                         dem_to_line_runner, 
-                         dem_to_line_runner_small,
-                          reduce_lines,
-                         image_splitting, 
+                         reduce_lines,
                          merge_lines_csv_to_shp, 
-                         merge_single_csv_to_shp, 
                          hillshade)
 import os 
 
 
-
 class ImageSplitterParallel(QRunnable):
     def __init__(self, i, crs, im, transform ,temp_folder):
         super().__init__()
@@ -64,10 +70,10 @@ class ImageSplitterParallel(QRunnable):
             
         new_dataset.write(Z, 1)
         new_dataset.close()
-    
 
 
 class MainWindow(QMainWindow):
+
     def __init__(self):
         super().__init__()
         self.threadpool = QThreadPool.globalInstance()
@@ -94,6 +100,8 @@ class MainWindow(QMainWindow):
         self.previewRegen.clicked.connect(self.previewRegenActionAndSmallCalc)
         self.extractButon.clicked.connect(self.extractLineamentAction)
 
+        self.aboutButton.clicked.connect(self.aboutAction)
+
         self.previewImageOverlaySelector.currentIndexChanged.connect(self.previewRegenAction)
         self.previewRegionSelector.currentIndexChanged.connect(self.previewRegenAction)
         self.hillshadeAngleSelector.currentIndexChanged.connect(self.previewRegenAction)
@@ -143,6 +151,9 @@ class MainWindow(QMainWindow):
 
         self.resetButton = QPushButton('Reset to Default')
         self.previewRegen = QPushButton('Regenerate Preview')
+        self.aboutButton = QPushButton('?')
+        self.aboutButton.setMaximumWidth(20)
+
         self.extractButon = QPushButton('Extract Lineament')
 
         self.subsetSideSlider, subsetSideLabel, subsetSideLayout = self.add_slider("Image Subset size", 500, 100, 2000, 50)
@@ -250,6 +261,7 @@ class MainWindow(QMainWindow):
         leftLayout.addWidget(self.resetButton)
         # leftLayout.addWidget(self.previewRegen)
         leftLayout.addStretch()
+        leftLayout.addWidget(self.aboutButton)
         leftLayout.addWidget(self.extractButon)
 
 
@@ -266,8 +278,19 @@ class MainWindow(QMainWindow):
     def loadImageAndPreview(self):
         sz     = self.subsetSideSlider.value() * self.subsetSideSlider.step
 
+
         self.regions, self.dem, self.extent, self.crs_espg = read_raster(self.file_name, split_size=sz)
 
+        imgFormat = self.file_name.split('.')[-1]
+        if (imgFormat == 'jpg') or (imgFormat == 'jpeg'):
+            from PIL import Image
+            i = Image.open( r"C:\Users\user\Downloads\WhatsApp Image 2025-09-23 at 16.34.01.jpeg" )
+            self.orgImg = np.transpose(np.array(i),( 1,0,2))[:,::-1]
+
+        else:
+
+            self.orgImg = self.dem[::-1].T
+
         L,R,B,T = self.extent
 
         if (L == 0) & (T==0):
@@ -275,7 +298,9 @@ class MainWindow(QMainWindow):
 
 
         W, H    = abs(L-R), abs(B-T)
-        img = pg.ImageItem(self.dem[::-1].T)
+        # img = pg.ImageItem(self.dem[::-1].T)
+        img = pg.ImageItem(self.orgImg)
+
         img.setRect(L,B,W,H)
 
         self.previewBigImg.clear()
@@ -425,7 +450,6 @@ class MainWindow(QMainWindow):
         hs = hs.replace(' ', '').split('-')
         avgAng = (float(hs[0]) + float(hs[1])) /2
 
-
         if overlay == 'original image':
             img = self.demSubset
 
@@ -757,10 +781,35 @@ class MainWindow(QMainWindow):
                 os.removedirs(tempfolder)
 
 
-
-if __name__ == "__main__":
+    def aboutAction(self):
+        msg = QMessageBox(self)
+        msg.setWindowTitle("About PyLineament")
+        msg.setTextFormat(Qt.RichText)  # enable HTML formatting
+        msg.setTextInteractionFlags(Qt.TextSelectableByMouse | Qt.LinksAccessibleByMouse)
+        msg.setStandardButtons(QMessageBox.Ok)
+        msg.setText(
+            """<b>PyLineament</b><br><br>
+            PyLineament is an open-source Python toolkit for 
+            <b>automatic and regional-scale lineament extraction</b> 
+            from DEMs and remote sensing imagery.<br><br>
+            Version: 1.0.0<br>
+            Author: Epo Prasetya Kusumah - Universitas Pertamina<br>
+            License: MIT<br>
+            GitHub: <a href='https://github.com/epokus/pylineament'>github.com/epokus/pylineament</a><br><br>
+            <b>How to cite:</b><br>
+            Kusumah, E. P., (2025). <i>PyLineament: A Python Toolkit for Regional-Scale Lineament Extraction</i>. 
+            Version 1.0. <a href='https://github.com/epokus/pylineament'>https://github.com/epokus/pylineament</a><br><br>
+            © 2025 PyLineament Developers
+            """
+        )
+        msg.exec_()
+
+def main():
     app = QApplication(sys.argv)
     window = MainWindow()
     window.show()
     sys.exit(app.exec_())
 
+
+if __name__ == "__main__":
+    main()

{pylineament-0.1.0 → pylineament-0.1.1}/pylineament.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pylineament
-Version: 0.1.0
+Version: 0.1.1
 Summary: Python Geological Lineament extraction package
 Author-email: Epo Kusumah <epo.pk@universiaspertamina.ac.id>
 License-Expression: MIT

pylineament-0.1.1/pylineament.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+pylineament = pylineament.pylineament_ui:main

{pylineament-0.1.0 → pylineament-0.1.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "pylineament"
-version = "0.1.0"
+version = "0.1.1"
 description = "Python Geological Lineament extraction package"
 readme = "README.md"
 authors = [{ name="Epo Kusumah", email="epo.pk@universiaspertamina.ac.id" }]
@@ -47,6 +47,6 @@ dependencies = [
 Homepage = "https://github.com/epokus/pylineament"
 
 [project.scripts]
-lineUI = "lineui.pylineament_ui:MainWindow"
+pylineament = "pylineament.pylineament_ui:main"
 
 

pylineament-0.1.0/pylineament.egg-info/entry_points.txt

@@ -1,2 +0,0 @@
-[console_scripts]
-lineUI = lineui.pylineament_ui:MainWindow