WIP: extracting Geometry utilities from datacube-core

Related tags

Geolocation odc-geo
Overview

odc.geo

This is still work in progress.

This repository contains geometry related code extracted from Open Datacube.

For details and motivation see ODC-EP-06 enhancement proposal.

Comments
  • Delay epsg determination as much as possible

    Delay epsg determination as much as possible

    Introduce special state _epsg=0, that implies "epsg code is not known yet", _epsg=None means "epsg code is known to be absent".

    Force all CRS construction code paths through cache.

    opened by Kirill888 17
  • Add CRS.utm and support crs=

    Add CRS.utm and support crs="utm" inputs in to_crs methods

    UTM convenience methods

    1. CRS.utm(some_geom) picks appropriate utm zone for a given geometry and returns corresponding CRS object
    2. When transforming geometry or geobox accept crs="utm|utm-n|utm-s" as a valid destination crs, meaning pick "appropriate" utm CRS for an object being transformed.
    3. ~"appropriate UTM zone" is currently defined by the lon,lat of the centroid of the geometry~
    4. UTM zones that overlap with some_geom are located using pyproj, then zone with biggest overlap is chosen

    Snap to

    Adds GeoBox.snap_to(other), this method adjust source geobox slightly by shifting footprint by a sub-pixel amount such that pixel edges align exactly with pixel edges of the other geobox. Method returns adjusted copy of self. Method only works when it is possible to align pixels by pure translation only - same projection, same resolution, same orientation. ValueError is raised when it's not possible.

    Closes #59

    Enclosing

    Related to snap_to somewhat. GeoBox construction method that creates a new "pixel grid compatible" geobox that minimally covers some area.

    Generalized Slicing into GeoBox

    Overload geobox[roi] to support geometry types on input, footprint in the world can be converted to pixel space, from which pixel slice is computed.

    Closes #31

    opened by Kirill888 12
  • Preparing for release

    Preparing for release

    • Adding library description to readme and docs

    • Adding badges to readme on github

    • Adding readthedocs integration

    • Bumping version and fixing description in the wheel

    • Fixing up add some more __repr__ methods

    • Reverting changes to multipolygon constructor function

    • rename odc.geo._overlap to just odc.geo.overlap

    • fix in compute_reproject_roi when dst is an integer shrink of source

    opened by Kirill888 10
  • XY refactor

    XY refactor

    There were a bunch of places where it was not clear whether some tuple contains X,Y or Y,X data. It's confusing on the interface and confusing when reading code. This PR adds an XY[T] type and a bunch of constructor methods that make it easy to understand what order x,y parameters are added.

    Instead of using plain tuples those new types are used instead. On the input shape= parameters are still allowed to be supplied as plain (int, int) tuples and are equivalent to iyx_(y, x). Internally those properties are kept in XY[int] form. Similarly a 2d index is also allowed to be supplied as (int, int), as this is what allows some_thing[ix, iy] or some_thing[row, col] syntax, order depends on use case, but should be clearly stated in the docs.

    Resolution input parameters are allowed to be a single float, but plain tuples are not allowed as this causes order confusion. Single value resolution is equivalent to resyx_(-value, value).

    Change GeoBox constructor to accept shape

    Geobox(width, height, ...) interface is problematic for several reasons:

    1. not compatible with ndarray, where shape is used instead
    2. no type-safety, easy to get order wrong
    3. two parameters to configure single property

    Replacing width, height with a single parameter shape. This could be a simple (int, int) tuple for easier interop with ndarray. But one can choose to use more typesafe XY[int].

    Example of the change at call site

       # before change:
       GeoBox(512, 256, A, "espg:4326")
    
       # becomes
       ## if array order is "native" at call-site
       GeoBox((256, 512), A, "epsg:4326")
       ## if width/height orded is preferred
       GeoBox(ixy_(512, 256), A, "epsg:4326")
    
    opened by Kirill888 10
  • Dask  colorize vmin vmax error

    Dask colorize vmin vmax error

    this failed

    ---------------------------------------------------------------------------
    TypeError                                 Traceback (most recent call last)
    /tmp/ipykernel_19782/44836221.py in <cell line: 1>()
    ----> 1 newcheckdask = odc.geo.xr.colorize(newcheck['test'], cmap=newcmp,vmin=1,vmax=240)
    
    ~/exploracornzarr/lib/python3.8/site-packages/odc/geo/_rgba.py in colorize(x, cmap, attrs, clip, vmin, vmax)
        240 
        241         assert x.chunks is not None
    --> 242         data = da.map_blocks(
        243             _impl,
        244             x.data,
    
    ~/exploracornzarr/lib/python3.8/site-packages/dask/array/core.py in map_blocks(func, name, token, dtype, chunks, drop_axis, new_axis, meta, *args, **kwargs)
        732         adjust_chunks = None
        733 
    --> 734     out = blockwise(
        735         func,
        736         out_ind,
    
    ~/exploracornzarr/lib/python3.8/site-packages/dask/array/blockwise.py in blockwise(func, out_ind, name, token, dtype, adjust_chunks, new_axes, align_arrays, concatenate, meta, *args, **kwargs)
        274         from .utils import compute_meta
        275 
    --> 276         meta = compute_meta(func, dtype, *args[::2], **kwargs)
        277     return new_da_object(graph, out, chunks, meta=meta, dtype=dtype)
        278 
    
    ~/exploracornzarr/lib/python3.8/site-packages/dask/array/utils.py in compute_meta(func, _dtype, *args, **kwargs)
        158                 return None
        159 
    --> 160         if _dtype and getattr(meta, "dtype", None) != _dtype:
        161             with contextlib.suppress(AttributeError):
        162                 meta = meta.astype(_dtype)
    
    ~/exploracornzarr/lib/python3.8/site-packages/dask/delayed.py in __bool__(self)
        588 
        589     def __bool__(self):
    --> 590         raise TypeError("Truth of Delayed objects is not supported")
        591 
        592     __nonzero__ = __bool__
    
    TypeError: Truth of Delayed objects is not supported
    

    this works - but as your docs suggest, gives strange results

    newcheckdask = odc.geo.xr.colorize(newcheck['test'], cmap=newcmp,vmin=1,vmax=240)
    

    Have I done something wrong, or is there a bug?

    opened by RichardScottOZ 9
  • Mostly various cleanups and more tests + GCPs helpers

    Mostly various cleanups and more tests + GCPs helpers

    • Closes #52
    • maybe addresses #51
    • Add GeoBox.compat to convert to datacube version of GeoBox
    • In reproject use nan as fill value for float32 outputs if output nodata is not configured
      • fixes boundary effects when plotting float32 input on a map
    • In colorize handle nodata values properly for non float inputs
      • fixes boundary effects when plotting non-float inputs on a map
    • In colorize drop nodata attribute on the output array
    • In geobox display support non-epsg authority codes like ESRI
    • Better Dask support for GeoBox, CRS and GeoBoxTiles classes (fixes hashing)
    • Add GCP extraction utilities
    • Add Geometry[Point] -> XY[float] conversion
    • Deprecated Geometry.__iter__ interface to follow shapely deprecation of that
    • Fixes .odc.add_to for maps with custom projections
    opened by Kirill888 6
  • Support generic affine in xarray rasters

    Support generic affine in xarray rasters

    Motivation

    Code in xx.odc.geobox assumes that xarray raster data is axis aligned. That is the off-diagonal terms of the affine matrix are zero and so entire row of pixels will have the same Y coordinate and similarly entire column same X coordinate:

    |y\x|0|1|2|3| |-|-|-|-|-| |0|0,0|1,0|2,0|3,0| |1|0,1|1,1|2,1|3,1|

    This limitation means one can not use .odc.geobox on rotated images. For a lot of satellite data one swatch of observation happens on an angle, when this gets rendered into axis aligned image you end up with a large proportion of the mosaic image being empty. Supporting arbitrary affine transform could make it much easier to work with large scale mosaics for such data sources.

    Possible Implementations

    2-d axis

    Xarray supports 2d coordinate, so one could simply compute X,Y coordinate for every pixel and store that in two 2d arrays, one for X and one for Y.

    pix = img[r,c]
    coord = (img.x[c], img.y[r])  # axis aligned representation
    ...
    coord = (img.x[r,c], img.y[r,c]) # 2d-axis representation
    

    .odc.geobox could then detect that 2d axis are used and reconstruct affine matrix from coordinates similar to current implementation but it will need to be computed from 3 points (Affine matrix has 6 degrees of freedom).

    • :-1: Significant memory overhead (2 float32 values per pixel, so 8 bytes per pixel)
    • :-1: This representation demands axis being Dask arrays as well.
    • :+1: Same representation can be used for completely non-linear pixel to world mapping as well
    • :+1: Direct support for plotting from xarray itself

    Pixel coords + Affine matrix in attributes

    In this scheme we keep 1-d X,Y axis, but they contain pixel coordinates and not real world coordinates, so x = [0.5, 1.5, 2.5... W-0.5], that sort of thing. We then also need to store actual affine matrix in some attributes attached to x,y axis.

    In this scenario .odc.geobox needs to detect the fact that X,Y axis contain pixel coordinates rather than real world coordinates and instead extract affine matrix from attributes/encoding. Slicing should still work as we will have access to the original image coordinates which is what we need to compute world coordinates from. Need to experiment with the location and representation for affine matrix data and how that works with things like .to_netcdf|to_zarr.

    • affine format: 6 float values (string vs array vs dict)

    • attachment point: x,y axis vs crs axis vs band

    • :+1: Same memory requirements as axis aligned representation

    • :-1: xarray plotting won't display more than one dataset on the same axis properly

    opened by Kirill888 6
  • BUG: Shape/Bounds different with odc-geo compared to datacube

    BUG: Shape/Bounds different with odc-geo compared to datacube

    Currently testing transitioning from datacube to odc-geo in geocube: https://github.com/corteva/geocube/pull/95

    Have some scenarios in the tests where the shape is off by one: odc-geo: (y: 100001, x: 11) datacube: (y: 100001, x: 12)

    And the boundary differs: odc-geo: [1665945., 7018509., 1665478., 7018306.] datacube: [1665478., 7018306., 1665945., 7018509.]

    Are these changes expected?

    opened by snowman2 6
  • Support GCPGeoBoxes with few points only

    Support GCPGeoBoxes with few points only

    GCP

    When fitting polynomial use lower rank if only few points available.

    Closes #67

    New features

    • BoundingBox.boundary() generate points along the perimiter
    • {BoundingBox|GeoBox}.qr2sample quasi-random 2d sampling using R2 sequence
    • Geometry.assign_crs use different CRS without changing geometry itself
    • Geometry.transform(..., crs=) can now optionally change CRS of the transformed geometry
    • odc.geo.geom.triangulate wrapper for for shapely method
    • MaybeCRS now includes special Unset case to differentiate from None
    • More robust Geometry.geojson (support composite and crs=None geometries)
    • rio_geobox helper method in converters
    opened by Kirill888 4
  • Prepare for next release

    Prepare for next release

    • Support matplotlib colormaps in colorize/add_to
    • Change to_grba to use vmin=, vmax= instead of non-standard clamp=
    • Re-order API docs
    • Add documentation section for xarray extension
    • Add documentation section for working with rasters
    • Extended sample data to include country geometries from geopandas
    opened by Kirill888 4
  • Track CRS info in BoundingBox and changes to GeoBox constructors

    Track CRS info in BoundingBox and changes to GeoBox constructors

    1. BoundingBox was an odd one out without CRS info attached, now it has that

      • This enables other conveniences, two way conversion polygon<->bbox
    2. Changes to GeoBox.from_bbox

      • Can get CRS info directly from bounding box now
      • Replace confusing "align" that is pretty hard to explain with "anchor"

    Essentially if you take 0,0 in the real world, bring it to pixel space and locate pixel that contains it, then you want location within that pixel to be a certain point in [0, 1), [0, 1), so 0,0 is edge aligned, same as align=(0,0) used to be, and to get center aligned pixel you pick (0.5, 0.5). Also you can just not align at all, in which case resulted geobox will start at left,top and might go a little bit over right, bottom.

    Also adds some more convenience methods to bounding box and geobox.

    Closes #25

    opened by Kirill888 4
  • `GeoBox.zoom_to` with a resolution

    `GeoBox.zoom_to` with a resolution

    I've been trying to use odc-geo to define the target grid for regridding with xesmf. This works great so far, but one of the features I've been missing so far is creating a Dataset from the GeoBox.

    The naive version I've been using so far

    def to_dataset(geobox):
        def to_variable(dim, coord):
            data = coord.values
            units = coord.units
            resolution = coord.resolution
            if resolution < 0:
                data = data[::-1]
                resolution *= -1
            return xr.Variable(
                dims=dim, data=data, attrs={"units": units, "resolution": resolution}
            )
    
        coords = {
            name: to_variable(name, odc_coord)
            for name, odc_coord in geobox.coordinates.items()
        }
        return xr.Dataset(coords=coords)
    

    which obviously lacks support for affine transformations, assumes 1D coordinates, and the resolution trick should probably configurable (and off by default?)

    Did I miss anything? Do you know of a better way to do this? If not, would you be open to adding something like this to odc.geo.xr?

    opened by keewis 8
  • Setup testing for Python 3.10

    Setup testing for Python 3.10

    Currently odc-geo is tested in one single configuration: python 3.8 with optional dependencies installed to maximize test coverage. We should be testing things with minimal dependencies and with other versions of Python.

    opened by Kirill888 0
  • Use `GeoTransform` to get resolution for GeoBox?

    Use `GeoTransform` to get resolution for GeoBox?

    Related to: opendatacube/datacube-core#752

    Currently the resolution inside of the coordinate attributes are used:

    https://github.com/opendatacube/datacube-core/blob/05093b75a8f15b643c7047502ae27b662af2d9b4/datacube/utils/xarray_geoextensions.py#L133-L139

    GeoTransform is a property used by GDAL to store this information (https://gdal.org/drivers/raster/netcdf.html#georeference)

    Here is an example of reading in this property: https://github.com/corteva/rioxarray/blob/f658d5f829a88204b2ec7b239735aba31694ed0a/rioxarray/rioxarray.py#L540-L545

    Thoughts about supporting this as well?

    opened by snowman2 4
  • Expand visualization capabilities

    Expand visualization capabilities

    • [DONE] ~Output folium or ipyleaflet maps when libraries are available when displaying geometries/geoboxes/bounding boxes.~
    • Provide GeoJSON outputs for more types
    • Conversion to geopandas when available
    opened by Kirill888 1
  • Port xr_reproject from odc.algo

    Port xr_reproject from odc.algo

    Most of the low-level utilities needed for Dask-backed reprojection are already in odc-geo. This is mostly

    https://github.com/opendatacube/odc-geo/blob/11c59371d306e010e8cbc4b4b835a80005e3ec4e/odc/geo/geobox.py#L909

    and also: https://github.com/opendatacube/odc-geo/blob/11c59371d306e010e8cbc4b4b835a80005e3ec4e/odc/geo/overlap.py#L130

    Expected interface:

    xx = dc.load(.., dask_chunks= {}) # or any other supported load backend
    
    # automatically choose resolution and bounding box, align pixel edges to 0
    # automatically choose chunk size
    yy = xx.odc.to_crs("epsg:3857")
    
    # fully defined destination pixel plane
    # configurable destination chunking
    yy = xx.odc.reproject(GeoBox.from_bbox(..), chunks={'x': 2048, 'y': 4096})
    
    • Support Dask and non-Dask inputs
    • Support xarray and dask.dataarray
    • Support xarray Datasets as well as DataArray
    • Support reasonable automatic resolution, bbox and chunking determination
    • Support any number of leading dimensions as well as optional interleaved band dimension: ..., y, x[,band]
    opened by Kirill888 2
  • Verify thread-safety of CRS caching approach

    Verify thread-safety of CRS caching approach

    We are caching pyproj.CRS objects here:

    https://github.com/opendatacube/odc-geo/blob/202cd8aeb3b03a54d9e484c3514c19a8b57b1a7b/odc/geo/_crs.py#L31-L32

    And pyproj transformers here:

    https://github.com/opendatacube/odc-geo/blob/202cd8aeb3b03a54d9e484c3514c19a8b57b1a7b/odc/geo/_crs.py#L47-L48

    • What that means for multi-threaded access?
    • Should we use lock when populating cache?
    • Should we use thread local cache instead of locking?
    • What are the constraints of multi-threaded access in pyproj/PROJ itself
      • currently we are assuming that sharing CRS objects across threads is fine?
    • We should also add purging rules to those caches, or at least expose manual purge option.
    • We should understand cost of caching in terms of RAM, especially for transformers cache.
    opened by Kirill888 2
Releases(v0.3.3)
  • v0.3.3(Dec 27, 2022)

    What's Changed

    • Shapely 2.0 fixes by @Kirill888 in https://github.com/opendatacube/odc-geo/pull/81
    • Bump actions versions by @Kirill888 in https://github.com/opendatacube/odc-geo/pull/77
    • Add AnchorEnum to the docs by @Kirill888 in https://github.com/opendatacube/odc-geo/pull/78

    Full Changelog: https://github.com/opendatacube/odc-geo/compare/v0.3.2...v0.3.3

    Source code(tar.gz)
    Source code(zip)
  • v0.3.2(Oct 26, 2022)

    What's Changed

    Fixes import issues on Python 3.10 introduced in previous release

    • BUG: Use typing.Hashable instead of collections.Hashable by @snowman2 in https://github.com/opendatacube/odc-geo/pull/74

    Full Changelog: https://github.com/opendatacube/odc-geo/compare/v0.3.1...v0.3.2

    Source code(tar.gz)
    Source code(zip)
  • v0.3.1(Oct 24, 2022)

    What's Changed

    • Set pyproj lower bound to version 3
    • Fixes to workflows, css tweaks, https://github.com/opendatacube/odc-geo/pull/71
    • Delay epsg determination as much as possible by @snowman2 and @Kirill888 in https://github.com/opendatacube/odc-geo/pull/72
      • Better caching of rasterio.crs.CRS -> odc.geo.crs.CRS construction path
      • Avoid computing .epsg unless requested by the user. This is an expensive operation for CRSs that do now have EPSG code, https://github.com/opendatacube/datacube-core/issues/1321

    Full Changelog: https://github.com/opendatacube/odc-geo/compare/v0.3.0...v0.3.1

    Source code(tar.gz)
    Source code(zip)
  • v0.3.0(Sep 9, 2022)

    What's Changed

    • Support integer inputs for CRS constructor in https://github.com/opendatacube/odc-geo/pull/64
    • Add CRS.utm and support crs="utm" inputs in to_crs methods in https://github.com/opendatacube/odc-geo/pull/65
    • Implement reproject for dataset objects in https://github.com/opendatacube/odc-geo/pull/69
    • Geometry can be constructed from arbitrary GeoJSON, including type=FeatureCollection

    GeoBox

    • Add GCPGeoBox in https://github.com/opendatacube/odc-geo/pull/62 https://github.com/opendatacube/odc-geo/pull/68
    • Generalize slicing into GeoBox, can slice with any geometry, geobox or boundingbox
    • New methods for constructing GeoBox that match the grid of other geobox
      • GeoBox.snap_to, GeoBox.enclosing
    • Method for generating quasi-random pixel location samples
    • Method for projecting geometries between pixel and world coordinates, .project
    • rio_geobox converter method to read in geobox from rasterio file handle

    Various Small Improvements

    • Understand _FillValue attribute populated by rioxarray
    • More helper methods on the BoundingBox class
      • .boundary
      • .aoi
      • .qr2sample(..)
    • Geometry.assign_crs(..) and optional crs= in Geometry.transform(op, crs=..)
    • More robust .geojson(..) generation from geometries
    • Fixes in .dropna() to handle holes in polygons

    Full Changelog: https://github.com/opendatacube/odc-geo/compare/v0.2.2...v0.3.0

    Source code(tar.gz)
    Source code(zip)
  • v0.2.2(Sep 2, 2022)

    What's Changed

    • Hide GDAL warnings in compress function in https://github.com/opendatacube/odc-geo/pull/57
    • Account for src_nodata kwarg in xr_reproject by @valpesendorfer in https://github.com/opendatacube/odc-geo/pull/60
    • Handle GeoBoxes and Geometries that do not project cleanly in https://github.com/opendatacube/odc-geo/pull/61
      • Deal with nan and inf values in a more robust way than before
      • Add Geometry.filter and Geometry.dropna operations
    • Removed __array_interface__ from Geometry class
      • it's deprecated in shapely and is not used, and newer numpy warns about it
      • one can use a more explicit numpy.asarray(g.coords) instead anyway
      • with this removed it's easier to make ndarrays containing Geometry objects

    New Contributors

    • @valpesendorfer made their first contribution in https://github.com/opendatacube/odc-geo/pull/60

    Full Changelog: https://github.com/opendatacube/odc-geo/compare/v0.2.1...v0.2.2

    Source code(tar.gz)
    Source code(zip)
  • v0.2.1(Jul 6, 2022)

    What's Changed

    Fixes

    • Fixes in colorize|add_to when plotting data with missing pixels
    • Fixes .odc.add_to for maps with custom projections #50
    • Better CRS info display for non-EPSG GeoBoxes
    • Better Dask support for GeoBox, CRS and GeoBoxTiles classes (fixes hashing)

    New Features

    • Add GeoBox.compat to convert to datacube version of GeoBox
    • New features robust=True in colorize|add_to, user percentiles for clipping: vmin=2%, vmax=98% #52
    • Add GCP extraction utilities
    • Add Geometry[Point] -> XY[float] conversion

    Deprecations

    Deprecated iteration over Geometry class to follow shapely deprecation of that, use .geoms property instead.

    See this PR: https://github.com/opendatacube/odc-geo/pull/54

    Full Changelog: https://github.com/opendatacube/odc-geo/compare/v0.2.0...v0.2.1

    Source code(tar.gz)
    Source code(zip)
  • v0.2.0(Jun 2, 2022)

    What's Changed

    Fixes

    • Geobox resolution display for rotated geoboxes in https://github.com/opendatacube/odc-geo/pull/47
    • Some typos in docs (by @RichardScottOZ)

    New features

    • Adding display on a map https://github.com/opendatacube/odc-geo/pull/48
      • .add_to(map)
      • .map_bounds to interface with folium/ipyleaflet
    • Add more raster operations:
      • .to_rgba
      • .colorize
      • .compress (jpeg,png,webp for map displays)
    • Add GeoBox.to_crs method (convenient access to output_geobox method)
    • More docs

    Full Changelog: https://github.com/opendatacube/odc-geo/compare/v0.1.3...v0.2.0

    Source code(tar.gz)
    Source code(zip)
  • v0.1.3(May 12, 2022)

    What's Changed

    • Support arbitrary geoboxes in xarray (PR #44)
      • It is now possible to create xarray.DataArray with GeoBoxes that are not aligned to X/Y axis (i.e. have rotation/shear components)
    • Add chunks= and time= optional arguments to xr_zeros(..)
    • Add GeoBox model docs (PR #45)
    Source code(tar.gz)
    Source code(zip)
  • v0.1.2.post0(May 10, 2022)

  • v0.1.2(Apr 27, 2022)

    What's Changed

    • BoundingBox is now CRS aware
    • Changes to GeoBox.from_ interfaces, anchor= replaces align=
      • .from_polygon still accepts old-style align= for ease of datacube migration
    • Adding .odc.write_cog, .odc.to_cog methods
    • Adding .odc.reproject (only supports non-Dask inputs currently)
    • Adding .odc.output_geobox - finds reasonable destination geobox when projecting to other CRS
    • Packaging fixes (mypy types, thanks to @snowman2)
    • Fixes in GeoBox display code (was not handling empty cases well)
    • Some code refactoring
    Source code(tar.gz)
    Source code(zip)
  • v0.1.1(Mar 29, 2022)

  • v0.1.1rc0(Mar 25, 2022)

Owner
Open Data Cube
Open Data Cube
Wraps GEOS geometry functions in numpy ufuncs.

PyGEOS PyGEOS is a C/Python library with vectorized geometry functions. The geometry operations are done in the open-source geometry library GEOS. PyG

null 362 Dec 23, 2022
Constraint-based geometry sketcher for blender

Geometry Sketcher Constraint-based sketcher addon for Blender that allows to create precise 2d shapes by defining a set of geometric constraints like

null 1.7k Jan 2, 2023
Advanced raster and geometry manipulations

buzzard In a nutshell, the buzzard library provides powerful abstractions to manipulate together images and geometries that come from different kind o

Earthcube Lab 30 Jun 20, 2022
Python bindings and utilities for GeoJSON

geojson This Python library contains: Functions for encoding and decoding GeoJSON formatted data Classes for all GeoJSON Objects An implementation of

Jazzband 765 Jan 6, 2023
Python bindings and utilities for GeoJSON

geojson This Python library contains: Functions for encoding and decoding GeoJSON formatted data Classes for all GeoJSON Objects An implementation of

Jazzband 763 Dec 26, 2022
Allele-specific pipeline for unbiased read mapping(WIP), QTL discovery(WIP), and allelic-imbalance analysis

WASP2 (Currently in pre-development): Allele-specific pipeline for unbiased read mapping(WIP), QTL discovery(WIP), and allelic-imbalance analysis Requ

McVicker Lab 2 Aug 11, 2022
Core ML tools contain supporting tools for Core ML model conversion, editing, and validation.

Core ML Tools Use coremltools to convert machine learning models from third-party libraries to the Core ML format. The Python package contains the sup

Apple 3k Jan 8, 2023
Core utilities for Python packages

packaging Reusable core utilities for various Python Packaging interoperability specifications. This library provides utilities that implement the int

Python Packaging Authority 451 Jan 4, 2023
Bayesian-Torch is a library of neural network layers and utilities extending the core of PyTorch to enable the user to perform stochastic variational inference in Bayesian deep neural networks

Bayesian-Torch is a library of neural network layers and utilities extending the core of PyTorch to enable the user to perform stochastic variational inference in Bayesian deep neural networks. Bayesian-Torch is designed to be flexible and seamless in extending a deterministic deep neural network architecture to corresponding Bayesian form by simply replacing the deterministic layers with Bayesian layers.

Intel Labs 210 Jan 4, 2023
Poetry PEP 517 Build Backend & Core Utilities

Poetry Core A PEP 517 build backend implementation developed for Poetry. This project is intended to be a light weight, fully compliant, self-containe

Poetry 293 Jan 2, 2023
BBB streaming without Xorg and Pulseaudio and Chromium and other nonsense (heavily WIP)

BBB Streamer NG? Makes a conference like this... ...streamable like this! I also recorded a small video showing the basic features: https://www.youtub

Lukas Schauer 60 Oct 21, 2022
Experimental proxy for dumping the unencrypted packet data from Brawl Stars (WIP)

Brawl Stars Proxy Experimental proxy for version 39.99 of Brawl Stars. It allows you to capture the packets being sent between the Brawl Stars client

null 4 Oct 29, 2021
WIP SAT benchmarking tooling, written with only my personal use in mind.

SAT Benchmarking Some early work in progress tooling for running benchmarks and keeping track of the results when working on SAT solvers and related t

Jannis Harder 1 Dec 26, 2021
Opal-lang - A WIP programming language based on Python

thanks to aphitorite for the beautiful logo! opal opal is a WIP transcompiled pr

null 3 Nov 4, 2022
A GitHub Follower Bot that is a WIP.

GitHub Follower Bot (WIP) Work In Progress This bot is a WIP. There are still many features I plan to add and code I need to improve (I'm still fairly

Christian Deacon 71 Dec 29, 2022
WIP python/pygame 2D zombie shooter

2d-shooter project A single/multiplayer co-op survival small space zombie shooter. If you'd like to contribute, feel free to join the discord! INSTALL

null 36 Dec 8, 2022
[WIP]An ani-cli like cli tool for movies and webseries

mov-cli A cli to browse and watch movies. Installation This project is a work in progress. However, you can try it out python git clone https://github

null 166 Dec 30, 2022
Modern Desktop Jellyfin Client written in Python and Vue for the UI [WIP]

JellyPlayer Modern Jellyfin Client Installation Install Requirements: Install Python 3 Install dependencies Install node deps for frontend, go to Jell

Prayag Prajapati 57 Dec 12, 2022
a small library for extracting rich content from urls

A small library for extracting rich content from urls. what does it do? micawber supplies a few methods for retrieving rich metadata about a variety o

Charles Leifer 588 Dec 27, 2022