// DoRPC acts as a switchboard for RPC commands.
func (d *Data) DoRPC(req datastore.Request, reply *datastore.Response) error {
switch req.TypeCommand() {
case "load":
if len(req.Command) < 5 {
return fmt.Errorf("Poorly formatted load command. See command-line help.")
}
// Parse the request
var uuidStr, dataName, cmdStr, offsetStr string
filenames, err := req.FilenameArgs(1, &uuidStr, &dataName, &cmdStr, &offsetStr)
if err != nil {
return err
}
if len(filenames) == 0 {
return fmt.Errorf("Need to include at least one file to add: %s", req)
}
// Get offset
offset, err := dvid.StringToPoint(offsetStr, ",")
if err != nil {
return fmt.Errorf("Illegal offset specification: %s: %v", offsetStr, err)
}
// Get list of files to add
var addedFiles string
if len(filenames) == 1 {
addedFiles = filenames[0]
} else {
addedFiles = fmt.Sprintf("filenames: %s [%d more]", filenames[0], len(filenames)-1)
}
dvid.Debugf(addedFiles + "\n")
uuid, versionID, err := datastore.MatchingUUID(uuidStr)
if err != nil {
return err
}
if err = datastore.AddToNodeLog(uuid, []string{req.Command.String()}); err != nil {
return err
}
if err = d.LoadImages(versionID, offset, filenames); err != nil {
return err
}
if err := datastore.SaveDataByUUID(uuid, d); err != nil {
return err
}
return nil
case "composite":
if len(req.Command) < 6 {
return fmt.Errorf("Poorly formatted composite command. See command-line help.")
}
return d.CreateComposite(req, reply)
default:
return fmt.Errorf("Unknown command. Data type '%s' [%s] does not support '%s' command.",
d.DataName(), d.TypeName(), req.TypeCommand())
}
return nil
}
// ForegroundROI creates a new ROI by determining all non-background blocks.
func (d *Data) ForegroundROI(req datastore.Request, reply *datastore.Response) error {
if d.Values.BytesPerElement() != 1 {
return fmt.Errorf("Foreground ROI command only implemented for 1 byte/voxel data!")
}
// Parse the request
var uuidStr, dataName, cmdStr, destName, backgroundStr string
req.CommandArgs(1, &uuidStr, &dataName, &cmdStr, &destName, &backgroundStr)
// Get the version and repo
uuid, versionID, err := datastore.MatchingUUID(uuidStr)
if err != nil {
return err
}
if err = datastore.AddToNodeLog(uuid, []string{req.Command.String()}); err != nil {
return err
}
// Use existing destination data or a new ROI data.
var dest *roi.Data
dest, err = roi.GetByUUID(uuid, dvid.InstanceName(destName))
if err != nil {
config := dvid.NewConfig()
typeservice, err := datastore.TypeServiceByName("roi")
if err != nil {
return err
}
dataservice, err := datastore.NewData(uuid, typeservice, dvid.InstanceName(destName), config)
if err != nil {
return err
}
var ok bool
dest, ok = dataservice.(*roi.Data)
if !ok {
return fmt.Errorf("Could not create ROI data instance")
}
}
// Asynchronously process the voxels.
background, err := dvid.StringToPointNd(backgroundStr, ",")
if err != nil {
return err
}
go d.foregroundROI(versionID, dest, background)
return nil
}
func postNodeLogHandler(c web.C, w http.ResponseWriter, r *http.Request) {
uuid := c.Env["uuid"].(dvid.UUID)
jsonData := make(map[string][]string)
decoder := json.NewDecoder(r.Body)
if err := decoder.Decode(&jsonData); err != nil && err != io.EOF {
BadRequest(w, r, fmt.Sprintf("Malformed JSON request in body: %s", err))
return
}
logdata, ok := jsonData["log"]
if !ok {
BadRequest(w, r, "Could not find 'log' value in POSTed JSON.")
}
if err := datastore.AddToNodeLog(uuid, logdata); err != nil {
BadRequest(w, r, err)
return
}
}
func (d *Data) ConstructTiles(uuidStr string, tileSpec TileSpec, request datastore.Request) error {
config := request.Settings()
uuid, versionID, err := datastore.MatchingUUID(uuidStr)
if err != nil {
return err
}
if err = datastore.AddToNodeLog(uuid, []string{request.Command.String()}); err != nil {
return err
}
source, err := datastore.GetDataByUUID(uuid, d.Source)
if err != nil {
return err
}
src, ok := source.(*imageblk.Data)
if !ok {
return fmt.Errorf("Cannot construct imagetile for non-voxels data: %s", d.Source)
}
// Save the current tile specification
d.Levels = tileSpec
if err := datastore.SaveDataByUUID(uuid, d); err != nil {
return err
}
// Get size of tile at lowest resolution.
lastLevel := Scaling(len(tileSpec) - 1)
loresSpec, found := tileSpec[lastLevel]
if !found {
return fmt.Errorf("Illegal tile spec. Should have levels 0 to absent %d.", lastLevel)
}
var loresSize [3]float64
for i := 0; i < 3; i++ {
loresSize[i] = float64(loresSpec.Resolution[i]) * float64(DefaultTileSize[i])
}
loresMag := dvid.Point3d{1, 1, 1}
for i := Scaling(0); i < lastLevel; i++ {
levelMag := tileSpec[i].levelMag
loresMag[0] *= levelMag[0]
loresMag[1] *= levelMag[1]
loresMag[2] *= levelMag[2]
}
// Get min and max points in terms of distance.
var minPtDist, maxPtDist [3]float64
for i := uint8(0); i < 3; i++ {
minPtDist[i] = float64(src.MinPoint.Value(i)) * float64(src.VoxelSize[i])
maxPtDist[i] = float64(src.MaxPoint.Value(i)) * float64(src.VoxelSize[i])
}
// Adjust min and max points for the tileable surface at lowest resolution.
var minTiledPt, maxTiledPt dvid.Point3d
for i := 0; i < 3; i++ {
minInt, _ := math.Modf(minPtDist[i] / loresSize[i])
maxInt, _ := math.Modf(maxPtDist[i] / loresSize[i])
minTileCoord := int32(minInt)
maxTileCoord := int32(maxInt)
minTiledPt[i] = minTileCoord * DefaultTileSize[i] * loresMag[i]
maxTiledPt[i] = (maxTileCoord+1)*DefaultTileSize[i]*loresMag[i] - 1
}
sizeVolume := maxTiledPt.Sub(minTiledPt).AddScalar(1)
// Setup swappable ExtData buffers (the stitched slices) so we can be generating tiles
// at same time we are reading and stitching them.
var bufferLock [2]sync.Mutex
var sliceBuffers [2]*imageblk.Voxels
var bufferNum int
// Get the planes we should tile.
planes, err := config.GetShapes("planes", ";")
if planes == nil {
// If no planes are specified, construct imagetile for 3 orthogonal planes.
planes = []dvid.DataShape{dvid.XY, dvid.XZ, dvid.YZ}
}
outF, err := d.putTileFunc(versionID)
// sort the tile spec keys to iterate from highest to lowest resolution
var sortedKeys []int
for scaling, _ := range tileSpec {
sortedKeys = append(sortedKeys, int(scaling))
}
sort.Ints(sortedKeys)
for _, plane := range planes {
timedLog := dvid.NewTimeLog()
offset := minTiledPt.Duplicate()
switch {
case plane.Equals(dvid.XY):
width, height, err := plane.GetSize2D(sizeVolume)
if err != nil {
return err
}
dvid.Debugf("Tiling XY image %d x %d pixels\n", width, height)
for z := src.MinPoint.Value(2); z <= src.MaxPoint.Value(2); z++ {
server.BlockOnInteractiveRequests("imagetile.ConstructTiles [xy]")
sliceLog := dvid.NewTimeLog()
offset = offset.Modify(map[uint8]int32{2: z})
slice, err := dvid.NewOrthogSlice(dvid.XY, offset, dvid.Point2d{width, height})
if err != nil {
return err
}
bufferLock[bufferNum].Lock()
sliceBuffers[bufferNum], err = src.NewVoxels(slice, nil)
if err != nil {
return err
}
if err = src.GetVoxels(versionID, sliceBuffers[bufferNum], nil); err != nil {
return err
}
// Iterate through the different scales, extracting tiles at each resolution.
go func(bufferNum int, offset dvid.Point) {
defer bufferLock[bufferNum].Unlock()
timedLog := dvid.NewTimeLog()
for _, key := range sortedKeys {
scaling := Scaling(key)
levelSpec := tileSpec[scaling]
if err != nil {
dvid.Errorf("Error in tiling: %v\n", err)
return
}
if err := d.extractTiles(sliceBuffers[bufferNum], offset, scaling, outF); err != nil {
dvid.Errorf("Error in tiling: %v\n", err)
return
}
if int(scaling) < len(tileSpec)-1 {
if err := sliceBuffers[bufferNum].DownRes(levelSpec.levelMag); err != nil {
dvid.Errorf("Error in tiling: %v\n", err)
return
}
}
}
timedLog.Debugf("Tiled XY Tile using buffer %d", bufferNum)
}(bufferNum, offset)
sliceLog.Infof("Read XY Tile @ Z = %d, now tiling...", z)
bufferNum = (bufferNum + 1) % 2
}
timedLog.Infof("Total time to generate XY Tiles")
case plane.Equals(dvid.XZ):
width, height, err := plane.GetSize2D(sizeVolume)
if err != nil {
return err
}
dvid.Debugf("Tiling XZ image %d x %d pixels\n", width, height)
for y := src.MinPoint.Value(1); y <= src.MaxPoint.Value(1); y++ {
server.BlockOnInteractiveRequests("imagetile.ConstructTiles [xz]")
sliceLog := dvid.NewTimeLog()
offset = offset.Modify(map[uint8]int32{1: y})
slice, err := dvid.NewOrthogSlice(dvid.XZ, offset, dvid.Point2d{width, height})
if err != nil {
return err
}
bufferLock[bufferNum].Lock()
sliceBuffers[bufferNum], err = src.NewVoxels(slice, nil)
if err != nil {
return err
}
if err = src.GetVoxels(versionID, sliceBuffers[bufferNum], nil); err != nil {
return err
}
// Iterate through the different scales, extracting tiles at each resolution.
go func(bufferNum int, offset dvid.Point) {
defer bufferLock[bufferNum].Unlock()
timedLog := dvid.NewTimeLog()
for _, key := range sortedKeys {
scaling := Scaling(key)
levelSpec := tileSpec[scaling]
if err != nil {
dvid.Errorf("Error in tiling: %v\n", err)
return
}
if err := d.extractTiles(sliceBuffers[bufferNum], offset, scaling, outF); err != nil {
dvid.Errorf("Error in tiling: %v\n", err)
return
}
if int(scaling) < len(tileSpec)-1 {
if err := sliceBuffers[bufferNum].DownRes(levelSpec.levelMag); err != nil {
dvid.Errorf("Error in tiling: %v\n", err)
return
}
}
}
timedLog.Debugf("Tiled XZ Tile using buffer %d", bufferNum)
}(bufferNum, offset)
sliceLog.Infof("Read XZ Tile @ Y = %d, now tiling...", y)
bufferNum = (bufferNum + 1) % 2
}
timedLog.Infof("Total time to generate XZ Tiles")
case plane.Equals(dvid.YZ):
width, height, err := plane.GetSize2D(sizeVolume)
if err != nil {
return err
}
dvid.Debugf("Tiling YZ image %d x %d pixels\n", width, height)
for x := src.MinPoint.Value(0); x <= src.MaxPoint.Value(0); x++ {
server.BlockOnInteractiveRequests("imagetile.ConstructTiles [yz]")
sliceLog := dvid.NewTimeLog()
offset = offset.Modify(map[uint8]int32{0: x})
slice, err := dvid.NewOrthogSlice(dvid.YZ, offset, dvid.Point2d{width, height})
if err != nil {
return err
}
bufferLock[bufferNum].Lock()
sliceBuffers[bufferNum], err = src.NewVoxels(slice, nil)
if err != nil {
return err
}
if err = src.GetVoxels(versionID, sliceBuffers[bufferNum], nil); err != nil {
return err
}
// Iterate through the different scales, extracting tiles at each resolution.
go func(bufferNum int, offset dvid.Point) {
defer bufferLock[bufferNum].Unlock()
timedLog := dvid.NewTimeLog()
for _, key := range sortedKeys {
scaling := Scaling(key)
levelSpec := tileSpec[scaling]
outF, err := d.putTileFunc(versionID)
if err != nil {
dvid.Errorf("Error in tiling: %v\n", err)
return
}
if err := d.extractTiles(sliceBuffers[bufferNum], offset, scaling, outF); err != nil {
dvid.Errorf("Error in tiling: %v\n", err)
return
}
if int(scaling) < len(tileSpec)-1 {
if err := sliceBuffers[bufferNum].DownRes(levelSpec.levelMag); err != nil {
dvid.Errorf("Error in tiling: %v\n", err)
return
}
}
}
timedLog.Debugf("Tiled YZ Tile using buffer %d", bufferNum)
}(bufferNum, offset)
sliceLog.Debugf("Read YZ Tile @ X = %d, now tiling...", x)
bufferNum = (bufferNum + 1) % 2
}
timedLog.Infof("Total time to generate YZ Tiles")
default:
dvid.Infof("Skipping request to tile '%s'. Unsupported.", plane)
}
}
return nil
}
// PutLocal adds image data to a version node, altering underlying blocks if the image
// intersects the block.
//
// The image filename glob MUST BE absolute file paths that are visible to the server.
// This function is meant for mass ingestion of large data files, and it is inappropriate
// to read gigabytes of data just to send it over the network to a local DVID.
func (d *Data) PutLocal(request datastore.Request, reply *datastore.Response) error {
timedLog := dvid.NewTimeLog()
// Parse the request
var uuidStr, dataName, cmdStr, sourceStr, planeStr, offsetStr string
filenames := request.CommandArgs(1, &uuidStr, &dataName, &cmdStr, &sourceStr,
&planeStr, &offsetStr)
if len(filenames) == 0 {
return fmt.Errorf("Need to include at least one file to add: %s", request)
}
// Get offset
offset, err := dvid.StringToPoint(offsetStr, ",")
if err != nil {
return fmt.Errorf("Illegal offset specification: %s: %v", offsetStr, err)
}
// Get list of files to add
var addedFiles string
if len(filenames) == 1 {
addedFiles = filenames[0]
} else {
addedFiles = fmt.Sprintf("filenames: %s [%d more]", filenames[0], len(filenames)-1)
}
dvid.Debugf(addedFiles + "\n")
// Get plane
plane, err := dvid.DataShapeString(planeStr).DataShape()
if err != nil {
return err
}
// Get Repo and IDs
uuid, versionID, err := datastore.MatchingUUID(uuidStr)
if err != nil {
return err
}
// Load and PUT each image.
numSuccessful := 0
for _, filename := range filenames {
sliceLog := dvid.NewTimeLog()
img, _, err := dvid.GoImageFromFile(filename)
if err != nil {
return fmt.Errorf("Error after %d images successfully added: %v", numSuccessful, err)
}
slice, err := dvid.NewOrthogSlice(plane, offset, dvid.RectSize(img.Bounds()))
if err != nil {
return fmt.Errorf("Unable to determine slice: %v", err)
}
vox, err := d.NewVoxels(slice, img)
if err != nil {
return err
}
storage.FileBytesRead <- len(vox.Data())
if err = d.PutVoxels(versionID, vox, nil); err != nil {
return err
}
sliceLog.Debugf("%s put local %s", d.DataName(), slice)
numSuccessful++
offset = offset.Add(dvid.Point3d{0, 0, 1})
}
if err := datastore.AddToNodeLog(uuid, []string{request.Command.String()}); err != nil {
return err
}
timedLog.Infof("RPC put local (%s) completed", addedFiles)
return nil
}
// DoRPC acts as a switchboard for RPC commands.
func (d *Data) DoRPC(req datastore.Request, reply *datastore.Response) error {
switch req.TypeCommand() {
case "load":
if len(req.Command) < 5 {
return fmt.Errorf("Poorly formatted load command. See command-line help.")
}
// Parse the request
var uuidStr, dataName, cmdStr, offsetStr string
filenames, err := req.FilenameArgs(1, &uuidStr, &dataName, &cmdStr, &offsetStr)
if err != nil {
return err
}
if len(filenames) == 0 {
hostname, _ := os.Hostname()
return fmt.Errorf("Couldn't find any files to add. Are they visible to DVID server on %s?",
hostname)
}
// Get offset
offset, err := dvid.StringToPoint(offsetStr, ",")
if err != nil {
return fmt.Errorf("Illegal offset specification: %s: %v", offsetStr, err)
}
// Get list of files to add
var addedFiles string
if len(filenames) == 1 {
addedFiles = filenames[0]
} else {
addedFiles = fmt.Sprintf("filenames: %s [%d more]", filenames[0], len(filenames)-1)
}
dvid.Debugf(addedFiles + "\n")
uuid, versionID, err := datastore.MatchingUUID(uuidStr)
if err != nil {
return err
}
if err = datastore.AddToNodeLog(uuid, []string{req.Command.String()}); err != nil {
return err
}
return d.LoadImages(versionID, offset, filenames)
case "put":
if len(req.Command) < 7 {
return fmt.Errorf("Poorly formatted put command. See command-line help.")
}
source := req.Command[4]
switch source {
case "local":
return d.PutLocal(req, reply)
case "remote":
return fmt.Errorf("put remote not yet implemented")
default:
return fmt.Errorf("Unknown command. Data instance '%s' [%s] does not support '%s' command.",
d.DataName(), d.TypeName(), req.TypeCommand())
}
case "roi":
if len(req.Command) < 6 {
return fmt.Errorf("Poorly formatted roi command. See command-line help.")
}
return d.ForegroundROI(req, reply)
default:
return fmt.Errorf("Unknown command. Data instance '%s' [%s] does not support '%s' command.",
d.DataName(), d.TypeName(), req.TypeCommand())
}
return nil
}
// CreateComposite creates a new rgba8 image by combining hash of labels + the grayscale
func (d *Data) CreateComposite(request datastore.Request, reply *datastore.Response) error {
timedLog := dvid.NewTimeLog()
// Parse the request
var uuidStr, dataName, cmdStr, grayscaleName, destName string
request.CommandArgs(1, &uuidStr, &dataName, &cmdStr, &grayscaleName, &destName)
// Get the version
uuid, v, err := datastore.MatchingUUID(uuidStr)
if err != nil {
return err
}
// Log request
if err = datastore.AddToNodeLog(uuid, []string{request.Command.String()}); err != nil {
return err
}
// Get the grayscale data.
dataservice, err := datastore.GetDataByUUIDName(uuid, dvid.InstanceName(grayscaleName))
if err != nil {
return err
}
grayscale, ok := dataservice.(*imageblk.Data)
if !ok {
return fmt.Errorf("%s is not the name of uint8 data", grayscaleName)
}
// Create a new rgba8blk data.
var compservice datastore.DataService
compservice, err = datastore.GetDataByUUIDName(uuid, dvid.InstanceName(destName))
if err == nil {
return fmt.Errorf("Data instance with name %q already exists", destName)
}
typeService, err := datastore.TypeServiceByName("rgba8blk")
if err != nil {
return fmt.Errorf("Could not get rgba8 type service from DVID")
}
config := dvid.NewConfig()
compservice, err = datastore.NewData(uuid, typeService, dvid.InstanceName(destName), config)
if err != nil {
return err
}
composite, ok := compservice.(*imageblk.Data)
if !ok {
return fmt.Errorf("Error: %s was unable to be set to rgba8 data", destName)
}
// Iterate through all labels and grayscale chunks incrementally in Z, a layer at a time.
wg := new(sync.WaitGroup)
op := &compositeOp{grayscale, composite, v}
chunkOp := &storage.ChunkOp{op, wg}
store, err := d.GetOrderedKeyValueDB()
if err != nil {
return err
}
ctx := datastore.NewVersionedCtx(d, v)
extents := d.Extents()
blockBeg := imageblk.NewTKey(extents.MinIndex)
blockEnd := imageblk.NewTKey(extents.MaxIndex)
err = store.ProcessRange(ctx, blockBeg, blockEnd, chunkOp, storage.ChunkFunc(d.CreateCompositeChunk))
wg.Wait()
// Set new mapped data to same extents.
composite.Properties.Extents = grayscale.Properties.Extents
if err := datastore.SaveDataByUUID(uuid, composite); err != nil {
dvid.Infof("Could not save new data '%s': %v\n", destName, err)
}
timedLog.Infof("Created composite of %s and %s", grayscaleName, destName)
return nil
}