Delete all metadata associated with an image

@param {String}   imageIdentifier
@param {Function} callback
@return {ImboClient}
326687
function(imageIdentifier, callback) {
        var url = this.getMetadataUrl(imageIdentifier);

        request.del(this.getSignedResourceUrl('DELETE', url), callback);
        return this;
    }
816295
function handleImageLoad(adElement, adLoadedCallback) {
    var adImage = adElement.querySelector("img");
    if (adImage) {
        (function (adToInsert, adImage) {
            adImage.onload = function () {
                adLoadedCallback(adToInsert, true);
            };
        })(adElement, adImage);
    } else {
        adLoadedCallback(adElement, false);
    }
}
1136947
function (identifier) {
            var self = this;

            return self.needByIdentifier(identifier)
                .then(function (record) {
                    return self.destroy(
                       record.id
                    ).then(function (records) {
                        return records[0];
                    });
                });
        }
302592
static function cleanupRegisteredImages()
    {
        $createdImageArray =& $GLOBALS['eZImageCreatedArray'];
        if ( !is_array( $createdImageArray ) )
            return;
        foreach ( array_keys( $createdImageArray ) as $createImageKey )
        {
            $createdImage = $createdImageArray[$createImageKey];
            if ( is_resource( $createdImage ) and get_resource_type( $createdImage ) == 'gd' )
                ImageDestroy( $createdImage );
        }
    }
245881
function(imageIdentifier, options) {
        if (typeof imageIdentifier !== 'string' || imageIdentifier.length === 0) {
            throw new Error(
                '`imageIdentifier` must be a non-empty string, was "' + imageIdentifier + '"' +
                ' (' + typeof imageIdentifier + ')'
            );
        }

        options = options || {};

        return new ImageUrl({
            baseUrl: this.getHostForImageIdentifier(
                imageIdentifier,
                options.usePrimaryHost
            ),
            path: options.path,
            user: this.options.user,
            publicKey: this.options.publicKey,
            privateKey: this.options.privateKey,
            imageIdentifier: imageIdentifier
        });
    }
119291
function (deviceManifestIdentifier, feedIdentifier) {
      var path;
      if (deviceManifestIdentifier && feedIdentifier) {
        path = this.constructPath(constants.DEVICE_MANIFESTS, deviceManifestIdentifier,
                                  constants.FEEDS, feedIdentifier);
        return this.Core.DELETE(path);
      } else {
        return this.rejectRequest('Bad Request: A device manifest identifier and a feed identifier are required.');
      }
    }
47070
function(imageIdentifier, usePrimary) {
        if (usePrimary) {
            return this.options.hosts[0];
        }

        var dec = imageIdentifier.charCodeAt(imageIdentifier.length - 1);

        // If this is an old image identifier (32 character hex string),
        // maintain backwards compatibility
        if (imageIdentifier.match(/^[a-f0-9]{32}$/)) {
            dec = parseInt(imageIdentifier.substr(0, 2), 16);
        }

        return this.options.hosts[dec % this.options.hosts.length];
    }
852363
function(callback) {
      if (imagesPaths.length >= numberOfColumns * numberOfRows) return callback();

      var transparentImagePath = path.join(temporaryDirectoryPath, 'transparent.png');
      gm(width, height, '#00000000').write(transparentImagePath, function(error) {

        // Add as many as needed transparent images to the list of images
        var totalMissingImages = numberOfColumns * numberOfRows - imagesPaths.length;

        for (var i = 0; i < totalMissingImages; i++)
          imagesPaths.push(transparentImagePath);

        callback(error);
      });
    }
878010
public function replaceMetadata($imageIdentifier, array $metadata) {
        return $this->getCommand('ReplaceMetadata', array(
            'user' => $this->getUser(),
            'imageIdentifier' => $imageIdentifier,
            'metadata' => json_encode($metadata),
        ))->execute();
    }
769982
def clear(self):
        """"""
        self._imgobj = None
        try:
            # See if there is an image on the canvas
            self.canvas.delete_object_by_tag(self._canvas_img_tag)
            self.redraw()
        except KeyError:
            pass
145935
function(callback) {

      if (this.filters.length === 0) {
        this.setElement(this._originalImage);
        callback && callback();
        return;
      }

      var isLikelyNode = typeof Buffer !== 'undefined' && typeof window === 'undefined',
          imgEl = this._originalImage,
          canvasEl = fabric.document.createElement('canvas'),
          replacement = isLikelyNode ? new (require('canvas').Image) : fabric.document.createElement('img'),
          _this = this;

        if (!canvasEl.getContext && typeof G_vmlCanvasManager != 'undefined') {
          G_vmlCanvasManager.initElement(canvasEl);
        }

      canvasEl.width = imgEl.width;
      canvasEl.height = imgEl.height;

      canvasEl.getContext('2d').drawImage(imgEl, 0, 0, imgEl.width, imgEl.height);

      this.filters.forEach(function(filter) {
        filter && filter.applyTo(canvasEl);
      });

       /** @ignore */
      replacement.onload = function() {
        _this._element = replacement;
        callback && callback();
        replacement.onload = canvasEl = imgEl = null;
      };
      replacement.width = imgEl.width;
      replacement.height = imgEl.height;

      if (isLikelyNode) {
        var base64str = canvasEl.toDataURL('image/png').replace(/data:image\/png;base64,/, '');
        replacement.src = new Buffer(base64str, 'base64');
        _this._element = replacement;

        // onload doesn't fire in node, so we invoke callback manually
        callback && callback();
      }
      else {
        replacement.src = canvasEl.toDataURL('image/png');
      }

      return this;
    }
934673
function cleanIdentity(identity) {
  var userPackage = {};
  Object.keys(identity).forEach(function (key) {
    if (key.indexOf('BRIGHTSOCKET:') !== 0) {
      userPackage[key] = identity[key];
    }
  });
  return userPackage;
}
172833
def image_delete_properties(request, image_id, keys):
    """"""
    return glanceclient(request, '2').images.update(image_id, keys)
816671
function(imageUrl, callback) {
        var url = imageUrl.clone(),
            extension = url.getExtension(),
            imageId = url.getImageIdentifier(),
            host = this.getHostForImageIdentifier(imageId);

        var data = {
            imageIdentifier: imageId,
            user: url.getUser(),
            publicKey: url.getPublicKey(),
            query: url.getQueryString()
        };

        if (extension) {
            data.extension = extension;
        }

        // Reset to remove transformations/query string
        url.reset().setPath('/shorturls');

        request({
            method: 'POST',
            uri: this.getSignedResourceUrl('POST', url.toString()),
            json: data,
            onComplete: function(err, res, body) {
                if (err) {
                    return callback(err);
                } else if (!body || !body.id) {
                    return callback('No ShortUrl was returned from server');
                }

                callback(err, new ShortUrl({ baseUrl: host, id: body.id }));
            }
        });

        return this;
    }
782144
function del(id, callback) {

    callback = callback || emptyFn

    if (typeof callback !== 'function') {
      throw new TypeError('callback must be a function or empty')
    }

    if (!idIndexData[id]) {
      return callback(new Error('No object found with \'' + options.idProperty +
          '\' = \'' + id + '\''))
    }

    self.emit('delete', id)

    delete idIndexData[id]

    // Work around for dynamic property
    var find = {}
    find[options.idProperty] = id

    data.splice(_.findIndex(data, find), 1)

    saveFile('afterDelete', id, callback)
  }
1324968
function clearImageIdSpecificToolStateManager(element) {
    const enabledElement = external.cornerstone.getEnabledElement(element);

    if (
      !enabledElement.image ||
      toolState.hasOwnProperty(enabledElement.image.imageId) === false
    ) {
      return;
    }

    delete toolState[enabledElement.image.imageId];
  }
307009
public void deleteServerRegistrationHTTP(RESTRequest request,
                                             int clientID,
                                             ServerNotificationRegistration serverNotificationRegistration,
                                             String registrationID,
                                             JSONConverter converter) {
        //Get the client area
        ClientNotificationArea clientArea = getInboxIfAvailable(clientID, null);

        if (registrationID != null) {
            String[] artifacts = registrationID.split("_");
            int filterID = Integer.parseInt(artifacts[0]);
            int handbackID = Integer.parseInt(artifacts[1]);

            //Since this is not coming from our java client, the registration object will not have any IDs on them. So set the IDs before continuing.
            serverNotificationRegistration.filterID = filterID;
            serverNotificationRegistration.handbackID = handbackID;
        }

        clientArea.removeServerNotificationListener(request, serverNotificationRegistration, serverNotificationRegistration.operation == Operation.RemoveAll, converter,
                                                    true);
    }