Merge branch 'subpixelapi' of code.usgs.gov:astrogeology/autocnet into subpixelapi

import autocnet.utils

import autocnet.spatial

def get_data(filename):

    packagdir = autocnet.__path__[0]

    dirname = os.path.join(os.path.dirname(packagdir), 'data')

    fullname = os.path.join(dirname, filename)

    return fullname

def cuda(enable=False, gpu=0):

    # Classes/Methods that can vary if GPU is available

    """

    return geom.contains(Point(x, y))

def generate_random(number, polygon):

    points = []

    minx, miny, maxx, maxy = polygon.bounds

        i += 1

    return np.asarray(points)

def distribute_points_classic(geom, nspts, ewpts, use_mrr=True, **kwargs):

    """

    This is a decision tree that attempts to perform a

        valid = generate_random(ewpts * nspts, original_geom)

    return valid

def distribute_points_new(geom, nspts, ewpts, Session):

    """

    This is a decision tree that attempts to perform a

    sides of the geometry.

    This algorithm does not know anything about the units being used

    so the caller is responsible for acocunting for units (if appropriate)

    so the caller is responsible for accounting for units (if appropriate)

    in the passed funcs.

    Parameters

from sklearn.cluster import DBSCAN

from sklearn.neighbors import NearestNeighbors

from skimage.feature import blob_log, blob_doh

from skimage.feature import blob_log

from math import sqrt, atan2, pi

from hoggorm.mat_corr_coeff import RVcoeff

import math

                                  JsonEncoder, try_db_creation)

from autocnet.io.db.connection import new_connection, Parent

from autocnet.matcher import subpixel

from autocnet.matcher import cross_instrument_matcher as cim

from autocnet.matcher import ground 

from autocnet.vis.graph_view import plot_graph, cluster_plot

from autocnet.control import control

from autocnet.spatial.overlap import compute_overlaps_sql

        subpixel.subpixel_register_measure(self.Session, measureid, **kwargs)

    def propagate_control_network(self, control_net, **kwargs):

        cim.propagate_control_network(self.Session,

        ground.propagate_control_network(self.Session,

                                      self.config,

                                      self.dem,

                                      control_net)

    def generate_ground_points(self, ground_mosaic, **kwargs):

        cim.generate_ground_points(self.Session, ground_mosaic, **kwargs)

        ground.generate_ground_points(self.Session, ground_mosaic, **kwargs)

    def place_points_in_overlaps(self, nodes, **kwargs):

        overlap.place_points_in_overlaps(self.Session,

import os

import sys

import unittest

from unittest.mock import Mock, MagicMock, patch, PropertyMock

import warnings

import numpy as np

import pandas as pd

import pytest

from shapely.geometry import LinearRing

from autocnet.examples import get_path

from plio.io.io_gdal import GeoDataset