Remove motion-capture-replayer components.
431136
function () {
    var self = this;

    if (!this.isReplaying || !this.replayData) { return; }

    this.isReplaying = false;
    Object.keys(this.replayData).forEach(function removeReplayer (key) {
      if (key === 'camera') {
        self.cameraEl.removeComponent('motion-capture-replayer');
      } else {
        el = document.querySelector('#' + key);
        if (!el) {
          warn('No element with id ' + key);
          return;
        }
        el.removeComponent('motion-capture-replayer');
      }
    });
  }
161943
def purge_stream(self, stream_id, remove_definition=False, sandbox=None):
        
        super(AssetsChannel, self).purge_stream(
            stream_id=stream_id, remove_definition=remove_definition, sandbox=sandbox)
320681
function cleanupProxyOnDestroy (object) {
      if (api.mediaCapturer && api.mediaCapturer.id === object.id) {
        api.mediaCapturer = null;
      }
      else if (proxies.hasOwnProperty(object.id)) {
        delete proxies[object.id];
      }

      if (object.$) {
        object.$.remove();
      }
    }
394624
def unregister_signals(self):
        """"""
        # Unregister Record signals
        if hasattr(self, 'update_function'):
            records_signals.before_record_insert.disconnect(
                self.update_function)
            records_signals.before_record_update.disconnect(
                self.update_function)
        self.unregister_signals_oaiset()
899250
public void pruneUnusedCameras() {
		// Count how many views are used by each camera
		int histogram[] = new int[structure.cameras.length];

		for (int i = 0; i < structure.views.length; i++) {
			histogram[structure.views[i].camera]++;
		}

		// See which cameras need to be removed and create a look up table from old to new camera IDs
		int oldToNew[] = new int[structure.cameras.length];
		List<SceneStructureMetric.Camera> remaining = new ArrayList<>();
		for (int i = 0; i < structure.cameras.length; i++) {
			if( histogram[i] > 0 ) {
				oldToNew[i] = remaining.size();
				remaining.add(structure.cameras[i]);
			}
		}

		// Create the new camera array without the unused cameras
		structure.cameras = new SceneStructureMetric.Camera[remaining.size()];
		for (int i = 0; i < remaining.size(); i++) {
			structure.cameras[i] = remaining.get(i);
		}

		// Update the references to the cameras
		for (int i = 0; i < structure.views.length; i++) {
			SceneStructureMetric.View v = structure.views[i];
			v.camera = oldToNew[v.camera];
		}
	}
644169
private void cleanup() {
		if (zoomToRectangleGroup != null) {
			container.remove(zoomToRectangleGroup);
			zoomToRectangleGroup = null;
		}
		if (escapeHandler != null) {
			escapeHandler.removeHandler();
			escapeHandler = null;
		}
		mapPresenter.getContainerManager().removeVectorContainer(container);
	}
45339
def stop_playback(self):
        """"""
        self._sink.flush()
        self._sink.stop()
        self._playing = False
521763
def removeFromPlaylist(playlist,index,count,tracks)
      method = 'removeFromPlaylist'
      type = TODO
      args = {:playlist=>playlist,:index=>index,
        :count=>count,:tracks=>Rdio::keys(tracks)}
      return_object type,method,args,true
    end
611253
def delete(self):
        """"""
        if lib.EnvDeleteActivation(self._env, self._act) != 1:
            raise CLIPSError(self._env)

        self._env = None
605893
def _video_part_rIds(self):
        
        media_rId, video_rId = self._slide_part.get_or_add_video_media_part(
            self._video
        )
        return media_rId, video_rId
714171
def clean_videos(self):
        
        if self.videos:
            self.videos = [int(v) for v in self.videos if v is not None and is_valid_digit(v)]
497770
def _prune_components(self):
        
        seen_components = set(map(lambda x: x.component, self._remote_candidates))
        missing_components = self._components - seen_components
        if missing_components:
            self.__log_info('Components %s have no candidate pairs' % missing_components)
            self._components = seen_components
1252304
def Clean():
  """"""
  # Find all the compiled proto files and unlink them.
  for (root, _, files) in os.walk(ROOT):
    for filename in files:
      full_filename = os.path.join(root, filename)
      if full_filename.endswith("_pb2.py") or full_filename.endswith(
          "_pb2.pyc"):
        os.unlink(full_filename)
829379
function removeMediaEncoding (sdp, mediaType, encodingName) {
      var sdpLines = sdp.split('\r\n'),
          mLineIndex = SDPHelpers.getMLineIndex(sdpLines, mediaType),
          mLine = mLineIndex > -1 ? sdpLines[mLineIndex] : void 0,
          typesToRemove = [],
          payloadTypes,
          match;

      if (mLineIndex === -1) {
        // Error, missing M line
        return sdpLines.join('\r\n');
      }

      // Get all payload types that the line supports
      payloadTypes = SDPHelpers.getMLinePayloadTypes(mLine, mediaType);
      if (payloadTypes.length === 0) {
        // Error, invalid M line?
        return sdpLines.join('\r\n');
      }

      // Find the location of all the rtpmap lines that relate to +encodingName+
      // and any of the supported payload types
      var matcher = new RegExp('a=rtpmap:(' + payloadTypes.join('|') + ') ' +
                                            encodingName + '\\/\\d+', 'i');

      sdpLines = OT.$.filter(sdpLines, function(line, index) {
        match = line.match(matcher);
        if (match === null) return true;

        typesToRemove.push(match[1]);

        if (index < mLineIndex) {
          // This removal changed the index of the mline, track it
          mLineIndex--;
        }

        // remove this one
        return false;
      });

      if (typesToRemove.length > 0 && mLineIndex > -1) {
        // Remove all the payload types and we've removed from the media line
        sdpLines[mLineIndex] = SDPHelpers.removeTypesFromMLine(mLine, typesToRemove);
      }

      return sdpLines.join('\r\n');
    }
241058
private function CleanUp() {

		// remove possible empty keys
		$AVpossibleEmptyKeys = array('dataformat', 'bits_per_sample', 'encoder_options', 'streams', 'bitrate');
		foreach ($AVpossibleEmptyKeys as $dummy => $key) {
			if (empty($this->info['audio'][$key]) && isset($this->info['audio'][$key])) {
				unset($this->info['audio'][$key]);
			}
			if (empty($this->info['video'][$key]) && isset($this->info['video'][$key])) {
				unset($this->info['video'][$key]);
			}
		}

		// remove empty root keys
		if (!empty($this->info)) {
			foreach ($this->info as $key => $value) {
				if (empty($this->info[$key]) && ($this->info[$key] !== 0) && ($this->info[$key] !== '0')) {
					unset($this->info[$key]);
				}
			}
		}

		// remove meaningless entries from unknown-format files
		if (empty($this->info['fileformat'])) {
			if (isset($this->info['avdataoffset'])) {
				unset($this->info['avdataoffset']);
			}
			if (isset($this->info['avdataend'])) {
				unset($this->info['avdataend']);
			}
		}

		// remove possible duplicated identical entries
		if (!empty($this->info['error'])) {
			$this->info['error'] = array_values(array_unique($this->info['error']));
		}
		if (!empty($this->info['warning'])) {
			$this->info['warning'] = array_values(array_unique($this->info['warning']));
		}

		// remove "global variable" type keys
		unset($this->info['php_memory_limit']);

		return true;
	}
326934
def clear_components(self):
        

        ComponentRegistry._component_overlays = {}

        for key in self.list_components():
            self.remove_component(key)
131028
def purgeDeletedWidgets():
        """"""
        toremove = []
        for field in AbstractEditorWidget.funit_fields:
            if sip.isdeleted(field):
                toremove.append(field)
        for field in toremove:
            AbstractEditorWidget.funit_fields.remove(field)

        toremove = []
        for field in AbstractEditorWidget.tunit_fields:
            if sip.isdeleted(field):
                toremove.append(field)
        for field in toremove:
            AbstractEditorWidget.tunit_fields.remove(field)