Esempio n. 1
0
def fig2(plt,days,values):

    fig, axes = plt.subplots(4,1,figsize=(8,4))
    plt.subplots_adjust(hspace=0.5)

    ## plot each index
    for i in range(4):
    
        ## display MM/DD/YYYY
        axes[i].xaxis.set_major_formatter(dates.DateFormatter('%m/%d/%y'))
    
        ## label each new day/month/year
        axes[i].xaxis.set_major_locator(dates.MonthLocator())
        
        ## break up the i-th time series into quartiles
        horizon(axes[i],days[i],values[i],4)
        
        axes[i].grid()
        axes[i].set(title=filenames[i],ylabel='Value',xlabel='Time')
        
        pass

    plt.gcf().autofmt_xdate()
    
    ## display and save
    #plt.show()
    plt.savefig('stockMarket-Horizon.png')
    pass
Esempio n. 2
0
def create_isopach(hor1, hor2, extent='intersection'):
    """Create new horizon with the difference between hor1 and hor2."""
    if isinstance(extent, basestring):
        if extent.lower() == 'union':
            extent = bbox_union(hor1.grid_extents, hor2.grid_extents)
        elif extent.lower() == 'intersection':
            extent = bbox_intersection(hor1.grid_extents, hor2.grid_extents)
            if extent is None:
                raise ValueError('Horizons do not overlap!')
        else:
            raise ValueError('Invalid extent type specified')
    xmin, xmax, ymin, ymax = extent
    x, y = np.mgrid[xmin:xmax+1, ymin:ymax+1]
    hor1.grid_extents = extent
    hor2.grid_extents = extent

    grid = hor1.grid - hor2.grid
    mask = ~grid.mask * np.ones_like(grid, dtype=np.bool) 
    x, y, z, mask = x.ravel(), y.ravel(), grid.ravel(), mask.ravel()
    iso = horizon.horizon(x=x[mask], y=y[mask], z=z[mask])
    iso._grid = grid
    return iso
Esempio n. 3
0
def create_isopach(hor1, hor2, extent='intersection'):
    """Create new horizon with the difference between hor1 and hor2."""
    if isinstance(extent, basestring):
        if extent.lower() == 'union':
            extent = bbox_union(hor1.grid_extents, hor2.grid_extents)
        elif extent.lower() == 'intersection':
            extent = bbox_intersection(hor1.grid_extents, hor2.grid_extents)
            if extent is None:
                raise ValueError('Horizons do not overlap!')
        else:
            raise ValueError('Invalid extent type specified')
    xmin, xmax, ymin, ymax = extent
    x, y = np.mgrid[xmin:xmax+1, ymin:ymax+1]
    hor1.grid_extents = extent
    hor2.grid_extents = extent

    grid = hor1.grid - hor2.grid
    mask = ~grid.mask * np.ones_like(grid, dtype=np.bool)
    x, y, z, mask = x.ravel(), y.ravel(), grid.ravel(), mask.ravel()
    iso = horizon.horizon(x=x[mask], y=y[mask], z=z[mask])
    iso._grid = grid
    return iso
Esempio n. 4
0
            print("Skipping %d frames..." % counter)
        else:
            continue

    print("Frame %d" % counter)

    method = cv2.INTER_AREA
    frame_scale = cv2.resize(frame, (0, 0),
                             fx=scale,
                             fy=scale,
                             interpolation=method)
    cv2.imshow('scaled orig', frame_scale)
    frame_undist = cv2.undistort(frame_scale, K, np.array(dist))

    # test horizon detection
    lines = horizon.horizon(frame_undist)
    if not lines is None:
        #best_line = horizon.track_best(lines)
        best_line = lines[0]
        roll, pitch = horizon.get_camera_attitude(best_line, IK, cu, cv)
        if last_roll is None or last_pitch is None:
            roll_rate = 0
            pitch_rate = 0
        else:
            roll_rate = (roll - last_roll) * fps * d2r
            pitch_rate = (pitch - last_pitch) * fps * d2r
        last_roll = roll
        last_pitch = pitch
        horizon.draw(frame_undist, best_line, IK, cu, cv)
        row = {
            'frame': counter,
Esempio n. 5
0
def extractWindow(hor, vol, upper=0, lower=None, offset=0, region=None, 
                  masked=False):
    """Extracts a window around a horizion out of a geoprobe volume
    Input:
        hor: a geoprobe horizion object or horizion filename
        vol: a geoprobe volume object or volume filename
        upper: (default, 0) upper window interval around horizion in voxels 
        lower: (default, upper) lower window interval around horizion in voxels 
        offset: (default, 0) amount (in voxels) to offset the horizion by along
                the Z-axis
        region: (default, overlap between horizion and volume) sub-region to 
                use instead of full extent. Must be a 4-tuple of (xmin, xmax,
                ymin, ymax)
        masked: (default, False) if True, return a masked array where nodata 
                values in the horizon are masked. Otherwise, return an array
                where the nodata values are filled with 0.
    Output:
        returns a numpy volume "flattened" along the horizion
    """
    # If the lower window isn't specified, assume it's equal to the 
    # upper window
    if lower == None: lower=upper

    # If filenames are input instead of volume/horizion objects, create 
    # the objects
    if type(hor) == type('String'):
        hor = horizon.horizon(hor)
    if type(vol) == type('String'):
        vol = volume.volume(vol)

    #Gah, changed the way hor.grid works... Should probably change it back
    depth = hor.grid.T 

    # Find the overlap between the horizon and volume
    vol_extents = [vol.xmin, vol.xmax, vol.ymin, vol.ymax]
    hor_extents = [hor.xmin, hor.xmax, hor.ymin, hor.ymax]
    extents = bbox_intersection(hor_extents, vol_extents)

    # Raise ValueError if horizon and volume do not intersect
    if extents is None:
        raise ValueError('Input horizon and volume do not intersect!')

    # Find the overlap between the (optional) subregion current extent
    if region is not None: 
        extents = bbox_intersection(extents, region)
        if extents is None:
            raise ValueError('Specified region does not overlap with'\
                             ' horizon and volume')
        elif len(extents) != 4:
            raise ValueError('"extents" must be a 4-tuple of'\
                             ' (xmin, xmax, ymin, ymax)')

    xmin, xmax, ymin, ymax = extents

    # Convert extents to volume indicies and select subset of the volume 
    xstart, ystart = xmin - vol.xmin, ymin - vol.ymin
    xstop, ystop = xmax - vol.xmin, ymax - vol.ymin
    data = vol.data[xstart:xstop, ystart:ystop, :]

    # Convert extents to horizion grid indicies and select 
    # subset of the horizion 
    xstart, ystart = xmin - hor.xmin, ymin - hor.ymin
    xstop, ystop = xmax - hor.xmin, ymax - hor.ymin
    depth = depth[xstart:xstop, ystart:ystop]

    nx,ny,nz = data.shape
    
    # convert z coords of horizion to volume indexes
    depth -= vol.zmin
    depth /= abs(vol.dz)
    depth = depth.astype(np.int)

    # Initalize the output array
    window_size = upper + lower + 1
    # Not creating a masked array here due to speed problems when 
    # iterating through ma's
    subVolume = np.zeros((nx,ny,window_size), dtype=np.uint8)

    # Using fancy indexing to do this uses tons of memory...
    # As it turns out, simple iteration is much, much more memory 
    # efficient, and almost as fast
    mask = depth.mask      # Need to preserve the mask for later
    depth = depth.filled() # Iterating through masked arrays is much slower...
    for i in xrange(nx):
        for j in xrange(ny):
            if depth[i,j] != hor.nodata:
                # Where are we in data indicies
                z = depth[i,j] + offset
                top = z - upper 
                bottom = z + lower + 1

                # Be careful to extract the right vertical region in cases
                # where the window goes outside the data bounds (find region of
                # overlap)
                data_top = max([top, 0]) 
                data_bottom = min([bottom, nz]) 
                window_top = max([0, window_size - bottom])
                window_bottom = min([window_size, nz - top])

                # Extract the window out of data and store it in subVolume
                subVolume[i, j, window_top : window_bottom] \
                                = data[i, j, data_top : data_bottom]

    # If masked is True (input option), return a masked array
    if masked:
        nx,ny,nz = subVolume.shape
        mask = mask.reshape((nx,ny,1))
        mask = np.tile(mask, (1,1,nz))
        subVolume = np.ma.array(subVolume, mask=mask)

    # If upper==lower==0, (default) subVolume will be (nx,ny,1), so 
    # return 2D array instead
    subVolume = subVolume.squeeze()

    return subVolume
Esempio n. 6
0
def extractWindow(hor, vol, upper=0, lower=None, offset=0, region=None,
                  masked=False):
    """Extracts a window around a horizion out of a geoprobe volume
    Input:
        hor: a geoprobe horizion object or horizion filename
        vol: a geoprobe volume object or volume filename
        upper: (default, 0) upper window interval around horizion in voxels
        lower: (default, upper) lower window interval around horizion in voxels
        offset: (default, 0) amount (in voxels) to offset the horizion by along
                the Z-axis
        region: (default, overlap between horizion and volume) sub-region to
                use instead of full extent. Must be a 4-tuple of (xmin, xmax,
                ymin, ymax)
        masked: (default, False) if True, return a masked array where nodata
                values in the horizon are masked. Otherwise, return an array
                where the nodata values are filled with 0.
    Output:
        returns a numpy volume "flattened" along the horizion
    """
    # If the lower window isn't specified, assume it's equal to the
    # upper window
    if lower == None: lower=upper

    # If filenames are input instead of volume/horizion objects, create
    # the objects
    if type(hor) == type('String'):
        hor = horizon.horizon(hor)
    if type(vol) == type('String'):
        vol = volume.volume(vol)

    #Gah, changed the way hor.grid works... Should probably change it back
    depth = hor.grid.T

    # Find the overlap between the horizon and volume
    vol_extents = [vol.xmin, vol.xmax, vol.ymin, vol.ymax]
    hor_extents = [hor.xmin, hor.xmax, hor.ymin, hor.ymax]
    extents = bbox_intersection(hor_extents, vol_extents)

    # Raise ValueError if horizon and volume do not intersect
    if extents is None:
        raise ValueError('Input horizon and volume do not intersect!')

    # Find the overlap between the (optional) subregion current extent
    if region is not None:
        extents = bbox_intersection(extents, region)
        if extents is None:
            raise ValueError('Specified region does not overlap with'\
                             ' horizon and volume')
        elif len(extents) != 4:
            raise ValueError('"extents" must be a 4-tuple of'\
                             ' (xmin, xmax, ymin, ymax)')

    xmin, xmax, ymin, ymax = extents

    # Convert extents to volume indicies and select subset of the volume
    i, j = vol.model2index([xmin, xmax], [ymin, ymax])
    data = vol.data[i[0]:i[1], j[0]:j[1], :]

    # Convert extents to horizion grid indicies and select
    # subset of the horizion

    hxmin, hxmax, hymin, hymax = hor.grid_extents
    xstart, ystart = xmin - hxmin, ymin - hymin
    xstop, ystop = xmax - hxmin, ymax - hymin
    depth = depth[xstart:xstop, ystart:ystop]

    nx,ny,nz = data.shape

    # convert z coords of horizion to volume indexes
    depth -= vol.zmin
    depth /= abs(vol.dz)
    depth = depth.astype(np.int)

    # Initalize the output array
    window_size = upper + lower + 1
    # Not creating a masked array here due to speed problems when
    # iterating through ma's
    subVolume = np.zeros((nx,ny,window_size), dtype=np.uint8)

    # Using fancy indexing to do this uses tons of memory...
    # As it turns out, simple iteration is much, much more memory
    # efficient, and almost as fast
    mask = depth.mask.copy() # Need to preserve the mask for later
    if not mask.shape:
        mask = np.zeros(depth.shape, dtype=np.bool)
    depth = depth.filled()   # Iterating through masked arrays is much slower.
    for i in xrange(nx):
        for j in xrange(ny):
            if depth[i,j] != hor.nodata:
                # Where are we in data indicies
                z = depth[i,j] + offset
                if z < 0:
                    mask[i,j] = True
                    continue
                top = z - upper
                bottom = z + lower + 1

                # Be careful to extract the right vertical region in cases
                # where the window goes outside the data bounds (find region of
                # overlap)
                data_top = max([top, 0])
                data_bottom = min([bottom, nz])
                window_top = max([0, window_size - bottom])
                window_bottom = min([window_size, nz - top])

                # Extract the window out of data and store it in subVolume
                subVolume[i, j, window_top : window_bottom] \
                                = data[i, j, data_top : data_bottom]

    # If masked is True (input option), return a masked array
    if masked:
        nx,ny,nz = subVolume.shape
        mask = mask.reshape((nx,ny,1))
        mask = np.tile(mask, (1,1,nz))
        subVolume = np.ma.array(subVolume, mask=mask)

    # If upper==lower==0, (default) subVolume will be (nx,ny,1), so
    # return 2D array instead
    subVolume = subVolume.squeeze()

    return subVolume
# Save the diamond square image
Image.fromarray(
    (ds).astype('uint8')).convert('RGB').save('0-diamond-square.png')

# Binarize the diamond square
margin = 10
nb_pixels = ds.shape[0] * ds.shape[1]
mean = numpy.mean(ds)
binary = numpy.array((ds < mean - margin) + (ds > mean + margin),
                     dtype=numpy.int)

# take care of side borders
ds_h = binary.shape[0]
ds_w = binary.shape[1]
horizon_roughness = 0.65
b = horizon(binary.shape[0], horizon_roughness, ds_h // 20)
for i in range(binary.shape[0]):
    binary[i, 0:b[i]] = 0
b = horizon(binary.shape[0], horizon_roughness, ds_h // 20)
for i in range(binary.shape[0]):
    binary[i, (binary.shape[1] - b[-i]):binary.shape[1]] = 0
b = horizon(binary.shape[1], horizon_roughness, ds_w // 20)
for i in range(binary.shape[1]):
    binary[0:b[i], i] = 0
b = horizon(binary.shape[1], horizon_roughness, ds_w // 20)
for i in range(binary.shape[1]):
    binary[(binary.shape[0] - b[-i]):binary.shape[0], i] = 0

# Save it for fun
Image.fromarray(
    (255 * binary).astype('uint8')).convert('RGB').save('1-binary.png')
Esempio n. 8
0
        else:
            continue

    #print("Frame %d" % counter)

    method = cv2.INTER_AREA
    frame_scale = cv2.resize(frame, (0, 0),
                             fx=scale,
                             fy=scale,
                             interpolation=method)
    cv2.imshow('scaled orig', frame_scale)
    frame_undist = cv2.undistort(frame_scale, K, np.array(dist))

    # test horizon detection
    if args.no_otsu:
        lines = horizon.horizon(frame_undist, False)
    else:
        lines = horizon.horizon(frame_undist)
    if not lines is None:
        #best_line = horizon.track_best(lines)
        best_line = lines[0]
        roll, pitch = horizon.get_camera_attitude(best_line, IK, cu, cv)
        if last_roll is None or last_pitch is None:
            roll_rate = 0
            pitch_rate = 0
        else:
            roll_rate = (roll - last_roll) * fps * d2r
            pitch_rate = (pitch - last_pitch) * fps * d2r
        last_roll = roll
        last_pitch = pitch
        horizon.draw(frame_undist, best_line, IK, cu, cv)