shancx 1.8.92__py3-none-any.whl → 1.9.33.218__py3-none-any.whl

shancx/user/hjnGIS.py

@@ -1,320 +0,0 @@
-from PIL import Image, ImageDraw
-import matplotlib.pyplot as plt
-from hjn.mkNCHJN import envelope,mkDir
-import numpy as np
-import netCDF4 as nc
-import copy
-import geopandas as gpd
-from osgeo import gdal, ogr, osr
-import os
-import shapely
-
-class maskClip():
-    def __init__(self,data,latAtt,lonArr,step):
-
-        self.dem = data
-        self.latArr = latAtt
-        self.lonArr = lonArr
-
-        oriStep=np.abs((self.latArr[0]-self.latArr[-1])/(len(self.latArr)-1))
-        range=int(np.round(step/oriStep,0))
-        self.dem=self.dem[::range,::range]
-
-        self.ltc = envelope(self.latArr[0], self.latArr[-1], self.lonArr[0], self.lonArr[-1])
-        self.step = step
-
-    def world2Pixel(self,ltc, x, y):
-        """
-        Uses a gdal geomatrix (gdal.GetGeoTransform()) to calculate
-        the pixel location of a geospatial coordinate
-        """
-        ulX = ltc.w
-        ulY = ltc.n
-        xDist = self.step
-
-        pixel = int((x - ulX) / xDist)
-        line = int((ulY - y) / xDist)
-        return (pixel, line)
-
-
-    def getMask(self,geom,minX,maxY,minY,maxX):
-
-        points = []
-        pixels = []
-        ulX, ulY = self.world2Pixel(self.ltc, minX, maxY)
-        lrX, lrY = self.world2Pixel(self.ltc, maxX, minY)
-
-        # Calculate the pixel size of the new image
-        pxWidth = int(lrX - ulX)
-        pxHeight = int(lrY - ulY)
-
-        ltc1 = copy.copy(self.ltc)
-        ltc1.n = maxY
-        ltc1.w = minX
-
-        pts = geom.boundary.xy
-        for p in range(len(pts[0])):
-            points.append((pts[0][p], pts[1][p]))
-        for p in points:
-            pixels.append(self.world2Pixel(ltc1, p[0], p[1]))
-        rasterPoly = Image.new("L", (pxWidth, pxHeight), 1)
-        rasterize = ImageDraw.Draw(rasterPoly)
-        if len(pixels) > 1:
-            rasterize.polygon(pixels, 0)
-
-        mask = np.asarray(rasterPoly)
-
-
-        # plt.imshow(mask)
-        # plt.show()
-
-        latOffset0 = int((self.ltc.n - maxY) / self.step)
-        latOffset1 = self.dem.shape[0] - int((self.ltc.n - minY) / self.step)
-        lonOffset0 = int((minX - self.ltc.w) / self.step)
-        lonOffset1 = self.dem.shape[1] - int((maxX - self.ltc.w) / self.step)
-        ndarray = np.pad(mask, ((latOffset0, latOffset1),
-                                (lonOffset0, lonOffset1)), 'constant', constant_values=(1, 1))
-
-        clip = copy.copy(self.dem)
-
-        clip[ndarray != 0] = np.nan
-
-        return clip
-
-
-
-    def clip(self,shapefile_path,encoding='gb18030'):
-        chly = gpd.GeoDataFrame.from_file(shapefile_path, encoding=encoding).geometry
-
-        minX, maxX, minY, maxY = chly.bounds.min().minx,chly.bounds.max().maxx,chly.bounds.min().miny,chly.bounds.max().maxy
-        maskArr=[]
-
-        for j in range(len(chly)):
-            geom = chly[j]
-            if geom.geometryType() == 'Polygon':
-                clip=self.getMask(geom, minX, maxY, minY, maxX)
-                maskArr.append(clip)
-            elif geom.geometryType() == "MultiPolygon":
-                multiLayer = []
-                for i in range(len(geom)):
-                    geom1 = geom[i]
-                    clip = self.getMask(geom1, minX, maxY, minY, maxX)
-                    multiLayer.append(clip)
-
-                multiLayer= np.asarray(multiLayer)
-                clip = np.nanmax(multiLayer,axis=0)
-                maskArr.append(clip)
-
-        return maskArr
-
-    def getMaskMask(self, geom, minX, maxY, minY, maxX):
-
-        points = []
-        pixels = []
-        ulX, ulY = self.world2Pixel(self.ltc, minX, maxY)
-        lrX, lrY = self.world2Pixel(self.ltc, maxX, minY)
-
-        # Calculate the pixel size of the new image
-        pxWidth = int(lrX - ulX)
-        pxHeight = int(lrY - ulY)
-
-        ltc1 = copy.copy(self.ltc)
-        ltc1.n = maxY
-        ltc1.w = minX
-
-        pt = geom.boundary
-        # print(pt)
-
-        if pt.type == "LineString":
-            pts = pt.xy
-            for p in range(len(pts[0])):
-                points.append((pts[0][p], pts[1][p]))
-            for p in points:
-                pixels.append(self.world2Pixel(ltc1, p[0], p[1]))
-            rasterPoly = Image.new("L", (pxWidth, pxHeight), 1)
-            rasterize = ImageDraw.Draw(rasterPoly)
-            if len(pixels) > 1:
-                rasterize.polygon(pixels, 0)
-
-            mask = np.asarray(rasterPoly)
-
-            latOffset0 = int((self.ltc.n - maxY) / self.step)
-            latOffset1 = self.dem.shape[0] - int((self.ltc.n - minY) / self.step)
-            lonOffset0 = int((minX - self.ltc.w) / self.step)
-            lonOffset1 = self.dem.shape[1] - int((maxX - self.ltc.w) / self.step)
-            ndarray = np.pad(mask, ((latOffset0, latOffset1),
-                                    (lonOffset0, lonOffset1)), 'constant', constant_values=(1, 1))
-
-            # clip = copy.copy(self.dem)
-            # clip[ndarray != 0] = np.nan
-            return mask
-        else:
-            # return
-            masks = []
-
-            for ptt in pt[:1]:
-                pts = ptt.xy
-                for p in range(len(pts[0])):
-                    points.append((pts[0][p], pts[1][p]))
-                for p in points:
-                    pixels.append(self.world2Pixel(ltc1, p[0], p[1]))
-                rasterPoly = Image.new("L", (pxWidth, pxHeight), 1)
-                rasterize = ImageDraw.Draw(rasterPoly)
-                if len(pixels) > 1:
-                    rasterize.polygon(pixels, 0)
-
-                mask = np.asarray(rasterPoly)
-                masks.append(mask)
-            masks = np.asarray(masks)
-            masks = np.min(masks, axis=0)
-            latOffset0 = int((self.ltc.n - maxY) / self.step)
-            latOffset1 = self.dem.shape[0] - int((self.ltc.n - minY) / self.step)
-            lonOffset0 = int((minX - self.ltc.w) / self.step)
-            lonOffset1 = self.dem.shape[1] - int((maxX - self.ltc.w) / self.step)
-            ndarray = np.pad(masks, ((latOffset0, latOffset1),
-                                     (lonOffset0, lonOffset1)), 'constant', constant_values=(1, 1))
-
-            clip = copy.copy(self.dem)
-            clip[ndarray != 0] = np.nan
-            return clip
-
-    def clipMask(self,chlyTable):
-        # chlyTable = gpd.GeoDataFrame.from_file(shapefile_path, encoding=encoding)
-        chly = chlyTable.geometry
-        minX, maxX, minY, maxY = chly.bounds.min().minx,chly.bounds.max().maxx,chly.bounds.min().miny,chly.bounds.max().maxy
-        maskArr=[]
-
-        for j in range(len(chly)):
-            geom = chly.iloc[j]
-            if geom.geometryType() == 'Polygon':
-                clip=self.getMaskMask(geom, minX, maxY, minY, maxX)
-                if not clip is None:
-                    maskArr.append(clip)
-
-            elif geom.geometryType() == "MultiPolygon":
-                multiLayer = []
-                for i in range(len(geom)):
-                    geom1 = geom[i]
-                    clip = self.getMaskMask(geom1, minX, maxY, minY, maxX)
-                    multiLayer.append(clip)
-
-                multiLayer= np.asarray(multiLayer)
-                clip = np.nanmin(multiLayer,axis=0)
-                if not clip is None:
-                    maskArr.append(clip)
-
-        return maskArr
-
-
-class slope_aspect():
-    def __init__(self,gridNew,dx, dy):
-        self.gridNew = gridNew
-        self.dx = dx
-        self.dy = dy
-        self.Sx, self.Sy = self.calcFiniteSlopes(gridNew, self.dx, self.dy)
-    # 计算dx,dy
-    def calcFiniteSlopes(self,elevGrid, dx, dy):
-        Zbc = np.pad(elevGrid, ((1, 1), (1, 1)), "edge")
-        Sx = (Zbc[1:-1, :-2] - Zbc[1:-1, 2:]) / (2 * dx)  # WE方向
-        Sy = (Zbc[2:, 1:-1] - Zbc[:-2, 1:-1]) / (2 * dy)  # NS方向
-        return Sx, Sy
-
-    def calcFiniteAspect(self,Sx, Sy):
-
-        Sx = Sx.astype(np.float)
-        Sy = Sy.astype(np.float)
-        aspect = np.degrees(np.arctan2(Sy, Sx))
-        aspect1 = copy.copy(aspect)
-        aspect1[aspect < 0] = 90 - aspect[aspect < 0]
-        aspect1[aspect > 90] = 360.0 - aspect[aspect > 90] + 90.0
-        aspect1[np.logical_and(aspect <= 90, aspect >= 0)] = 90.0 - aspect[np.logical_and(aspect <= 90, aspect >= 0)]
-        aspect1[np.logical_and(Sx == 0, Sy == 0)] = -1
-        return aspect1
-
-    def getSlop(self):
-        return np.degrees(np.arctan(np.sqrt(self.Sx ** 2 + self.Sy ** 2)))
-
-    def getAspect(self):
-        return self.calcFiniteAspect(self.Sx, self.Sy)
-
-
-def Polygonize(mask,latArr,lonArr,outshp,EPSG=4326):
-    driver = gdal.GetDriverByName("GTiff")
-    im_bands = 1
-    dataset = driver.Create("./tmp.tiff", mask.shape[1], mask.shape[0], im_bands, gdal.GDT_UInt16)
-    im_geotrans = (lonArr[0], lonArr[1]-lonArr[0], 0, latArr[0], 0, latArr[1]-latArr[0])
-    dataset.SetGeoTransform(im_geotrans)
-    prj = osr.SpatialReference()
-    prj.ImportFromEPSG(EPSG)
-    dataset.SetProjection(prj.ExportToWkt())
-    dataset.GetRasterBand(1).WriteArray(mask) 
-    inband = dataset.GetRasterBand(1)
-    mkDir(outshp)
-    drv = ogr.GetDriverByName("ESRI Shapefile")
-    if os.path.exists(outshp):
-        drv.DeleteDataSource(outshp)
-    Polygon = drv.CreateDataSource(outshp)
-    Poly_layer = Polygon.CreateLayer(outshp, srs=prj,
-                                     geom_type=ogr.wkbMultiPolygon)
-    newField = ogr.FieldDefn('value', ogr.OFTReal)
-    Poly_layer.CreateField(newField)
-    gdal.FPolygonize(inband, None, Poly_layer, 0)
-    Polygon.SyncToDisk()
-    del Polygon
-    os.remove("./tmp.tiff")
-
-def Polylinize(mask, latArr, lonArr, outshp, EPSG=4326):
-    driver = gdal.GetDriverByName("GTiff")
-    im_bands = 1
-    dataset = driver.Create("./tmp.tiff", mask.shape[1], mask.shape[0], im_bands, gdal.GDT_UInt16)
-    im_geotrans = (lonArr[0], lonArr[1]-lonArr[0], 0, latArr[0], 0, latArr[1]-latArr[0])
-    dataset.SetGeoTransform(im_geotrans)
-    prj = osr.SpatialReference()
-    prj.ImportFromEPSG(EPSG)
-    dataset.SetProjection(prj.ExportToWkt())
-    dataset.GetRasterBand(1).WriteArray(mask)
-    inband = dataset.GetRasterBand(1)
-    mkDir(outshp)
-    drv = ogr.GetDriverByName("ESRI Shapefile")
-    if os.path.exists(outshp):
-        drv.DeleteDataSource(outshp)
-    Polygon = drv.CreateDataSource(outshp)
-    Poly_layer = Polygon.CreateLayer(outshp, srs=prj,
-                                     geom_type=ogr.wkbLineString)
-    newField = ogr.FieldDefn('value', ogr.OFTReal)
-    Poly_layer.CreateField(newField)
-    gdal.FPolygonize(inband, None, Poly_layer, 0)
-    Polygon.SyncToDisk()
-    del Polygon
-    os.remove("./tmp.tiff")
-
-def polygon2polyline(shpFile, tolerance= 0.001):
-    gdf = gpd.read_file(shpFile)
-    lat0, lat1, lon1, lon0 = gdf.total_bounds
-
-    area = gpd.GeoSeries([shapely.geometry.Polygon([(lon0+tolerance,lat0-tolerance),(lon0+tolerance,lat1+tolerance),(lon1-tolerance,lat1+tolerance),(lon1-tolerance,lat0-tolerance)])],crs=gdf.crs)
-    mask_clip = gpd.clip(gdf, area).explode(index_parts=False)
-    new_gdf = gpd.GeoDataFrame([], columns=mask_clip.columns, crs=gdf.crs)
-    for i in set(mask_clip["value"]):
-        tmpDF = mask_clip[mask_clip["value"] == i]
-        aa = shapely.ops.linemerge(list(tmpDF.geometry))
-        tmp = gpd.GeoDataFrame([[i,aa]], columns=mask_clip.columns, crs=gdf.crs)
-        new_gdf = new_gdf.append(tmp)
-
-    new_gdf.reset_index(inplace=True,drop=True)
-    mask_clip = new_gdf.explode(index_parts=False)
-
-    new_gdf = gpd.GeoDataFrame([],columns=mask_clip.columns,crs=gdf.crs)
-    mask_clip = list(mask_clip.values)
-    while len(mask_clip)>0:
-        tmp = [mask_clip.pop()]
-        for j in range(1,len(mask_clip)):
-            if j>=len(mask_clip):
-                continue
-            if tmp[0][1].equals(mask_clip[j][1]):
-                tmp.append(mask_clip.pop(j))
-        gpdtmp = gpd.GeoDataFrame(tmp, columns=["value", "geometry"], crs=gdf.crs)
-        gpdtmp.sort_values("value",ascending=False,inplace=True)
-        new_gdf = new_gdf.append(gpdtmp.iloc[0])
-    return new_gdf
-

shancx/user/hjnGPU.py

@@ -1,21 +0,0 @@
-from gpuinfo import GPUInfo
-import numpy as np
-import time
-
-def findGPU(waitS=2):
-    """get ID of GPUS
-    :param num_gpu:  num of GPUs to use
-    :return: gpu_id: ID of allocated GPUs
-    """
-    gpu_id = None
-    waitSec = np.random.uniform(0,waitS)
-    time.sleep(waitSec)
-    available_device=GPUInfo.check_empty()
-    if not available_device is None:
-        if len(available_device)>0:
-            idx = np.random.randint(0,len(available_device))
-            gpu_id=available_device[idx]
-
-    return gpu_id
-
-

shancx/user/hjnIDW.py

@@ -1,68 +0,0 @@
-# Author : bb
-# Time : 2020/11/18 16:59
-# -*- coding: utf-8 -*-
-
-import numpy as np
-from sklearn.neighbors import KDTree
-np.seterr(divide='ignore',invalid='ignore')
-
-class IDW():
-    def __init__(self, y, x,   candidate=15):
-        self.disMat = None
-        self.idMat = None
-        self.disPoint = None
-        self.idPoint = None
-        self.x = x
-        self.y = y
-        self.resultMat = None
-        self.resultPont = None
-        self.candidate = candidate
-
-    def initDictMat(self,ltc,resolution=0.01):
-        self.evn = ltc
-        self.resolution = resolution
-        self.latRange = int((self.evn.n - self.evn.s + 10e-10) // self.resolution) + 1
-        self.lonRange = int((self.evn.e - self.evn.w + 10e-10) // self.resolution) + 1
-        self.latArr = np.linspace(self.evn.n, self.evn.s, self.latRange)
-        self.lonArr = np.linspace(self.evn.w, self.evn.e, self.lonRange)
-        latArr = np.linspace(self.evn.n, self.evn.s, self.latRange)
-        lonArr = np.linspace(self.evn.w, self.evn.e, self.lonRange)
-        lonMat, latMat = np.meshgrid(lonArr, latArr)
-        tree = KDTree(np.c_[self.y, self.x])
-        xyMesh = np.c_[latMat.reshape(-1), lonMat.reshape(-1)]
-        dist, ind = tree.query(xyMesh, k=self.candidate)
-        self.disMat = dist.reshape([len(latArr), len(lonArr), self.candidate])
-        self.idMat = ind.reshape([len(latArr), len(lonArr), self.candidate])
-
-    def getMat(self,z):
-        valMat = z[self.idMat]
-        disAll = np.sum(1 / np.power(self.disMat, 2), axis=2)
-        dataAll = np.sum(valMat / np.power(self.disMat, 2), axis=2)
-        self.resultMat = dataAll / disAll
-        self.resultMat[self.disMat[:, :, 0] == 0] = valMat[self.disMat[:, :, 0] == 0, 0]
-        return self.resultMat
-
-    def initDictPoints(self,yP, xP):
-        tree = KDTree(np.c_[self.y, self.x])
-        xyMesh = np.c_[yP, xP]
-        dist, ind = tree.query(xyMesh, k=self.candidate)
-        self.disPoint = dist
-        self.idPoint = ind
-        print()
-
-    def getPoint(self, z):
-        valPont = z[self.idPoint]
-        disAll = np.sum(1 / np.power(self.disPoint, 2),axis=1)
-        dataAll = np.sum(valPont / np.power(self.disPoint, 2),axis=1)
-        self.resultPont = dataAll / disAll
-        self.resultPont[self.disPoint[:,0] == 0] = valPont[self.disPoint[:,0] == 0, 0]
-        return self.resultPont
-
-
-
-
-
-
-
-
-

shancx/user/hjnKDTree.py

@@ -1,75 +0,0 @@
-# -*- coding: utf-8 -*-
-
-from collections import namedtuple
-from operator import itemgetter
-from pprint import pformat
-import numpy as np
-
-
-class Node(namedtuple('Node', 'location left_child right_child')):
-    def __repr__(self):
-        return pformat(tuple(self))
-
-
-class KDTree():
-    def __init__(self, points):
-        self.tree = self._make_kdtree(points)
-        if len(points) > 0:
-            self.k = len(points[0])
-        else:
-            self.k = None
-
-    def _make_kdtree(self, points, depth=0):
-        if not points:
-            return None
-
-        k = len(points[0])
-        axis = depth % k
-
-        points.sort(key=itemgetter(axis))
-        median = len(points) // 2
-
-        return Node(
-            location=points[median],
-            left_child=self._make_kdtree(points[:median], depth + 1),
-            right_child=self._make_kdtree(points[median + 1:], depth + 1))
-
-    def find_nearest(self,
-                     point,
-                     root=None,
-                     axis=0,
-                     dist_func=lambda x, y: np.linalg.norm(x - y)):
-
-        if root is None:
-            root = self.tree
-            self._best = None
-
-        # 若不是叶节点，则继续向下走
-        if root.left_child or root.right_child:
-            new_axis = (axis + 1) % self.k
-            if point[axis] < root.location[axis] and root.left_child:
-                self.find_nearest(point, root.left_child, new_axis)
-            elif root.right_child:
-                self.find_nearest(point, root.right_child, new_axis)
-
-        # 回溯：尝试更新 best
-        dist = dist_func(root.location, point)
-        if self._best is None or dist < self._best[0]:
-            self._best = (dist, root.location)
-
-        # 若超球与另一边超矩形相交
-        if abs(point[axis] - root.location[axis]) < self._best[0]:
-            new_axis = (axis + 1) % self.k
-            if root.left_child and point[axis] >= root.location[axis]:
-                self.find_nearest(point, root.left_child, new_axis)
-            elif root.right_child and point[axis] < root.location[axis]:
-                self.find_nearest(point, root.right_child, new_axis)
-
-        return self._best
-
-if __name__ == '__main__':
-    point_list = [(2, 3), (5, 4), (9, 6), (4, 7), (8, 1), (7, 2)]
-    kdtree = KDTree(point_list)
-
-    point = np.array([5, 5])
-    print(kdtree.find_nearest(point))

shancx/user/hjnLAPSTransform.py

@@ -1,47 +0,0 @@
-# -*- coding:utf-8 -*-
-# Author:hujunnan
-
-import numpy as np
-
-# p = Proj("+proj=lcc +lat_0=30 +lon_0= 102 +lat_1=30 +lat_2=60")
-
-class LAPSTransfrom():
-    def __init__(self,p,lonMat, latMat,env=None,step=0.03):
-        xMat, yMat = p(lonMat, latMat)
-        x0 = np.min(xMat)
-        y0 = np.max(yMat)
-        if env is None:
-            n,s,w,e = np.max(latMat),np.min(latMat),np.min(lonMat),np.max(lonMat)
-            lat0 = n
-            lat1 = s
-            lon0 = w
-            lon1 = e
-        else:
-            lat0 = env.n
-            lat1 = env.s
-            lon0 = env.w
-            lon1 = env.e
-        self.step = step
-        self.rangeLat = int(np.ceil(((lat0 - lat1) / step))) + 1
-        self.rangeLon = int(np.ceil(((lon1 - lon0) / step))) + 1
-        self.latArr = np.asarray([lat0 - i*step for i in range(self.rangeLat)],np.float64)
-        self.lonArr = np.asarray([lon0 + i*step for i in range(self.rangeLon)],np.float64)
-        latMatCHN = np.repeat([self.latArr], self.rangeLon, axis=0).T
-        lonMatCHN = np.repeat([self.lonArr], self.rangeLat, axis=0)
-        latMatCHNArr = latMatCHN.reshape(-1)
-        lonMatCHNArr = lonMatCHN.reshape(-1)
-        x, y = p(lonMatCHNArr, latMatCHNArr)
-        self.latIdx = ((y0 - y) / (step*100000) + 0.5).astype(int)
-        self.lonIdx = ((x - x0) / (step*100000) + 0.5).astype(int)
-        self.latMaskValid = np.logical_or(self.latIdx < 0, self.latIdx >= latMat.shape[0])
-        self.lonMaskValid = np.logical_or(self.lonIdx < 0, self.lonIdx >= latMat.shape[1])
-        self.latIdx[self.latMaskValid] = 0
-        self.lonIdx[self.lonMaskValid] = 0
-
-    def LambertToLatLon(self,t):
-        lambertMat = t[self.latIdx, self.lonIdx]
-        lambertMat = lambertMat.reshape([self.rangeLat, self.rangeLon])
-        lambertMat[self.latMaskValid.reshape([self.rangeLat, self.rangeLon])] = np.nan
-        lambertMat[self.lonMaskValid.reshape([self.rangeLat, self.rangeLon])] = np.nan
-        return lambertMat
-