Detectar mudanças de imagem em um arquivo de vídeo armazenado localmente.
Páginas de documentação que incluem esta amostra de código
Para visualizar o exemplo de código usado em contexto, consulte a seguinte documentação:
Amostra de código
Go
func shotChangeURI(w io.Writer, file string) error {
ctx := context.Background()
client, err := video.NewClient(ctx)
if err != nil {
return err
}
defer client.Close()
op, err := client.AnnotateVideo(ctx, &videopb.AnnotateVideoRequest{
Features: []videopb.Feature{
videopb.Feature_SHOT_CHANGE_DETECTION,
},
InputUri: file,
})
if err != nil {
return err
}
resp, err := op.Wait(ctx)
if err != nil {
return err
}
// A single video was processed. Get the first result.
result := resp.AnnotationResults[0].ShotAnnotations
for _, shot := range result {
start, _ := ptypes.Duration(shot.StartTimeOffset)
end, _ := ptypes.Duration(shot.EndTimeOffset)
fmt.Fprintf(w, "Shot: %s to %s\n", start, end)
}
return nil
}
Java
// Instantiate a com.google.cloud.videointelligence.v1.VideoIntelligenceServiceClient
try (VideoIntelligenceServiceClient client = VideoIntelligenceServiceClient.create()) {
// Provide path to file hosted on GCS as "gs://bucket-name/..."
AnnotateVideoRequest request =
AnnotateVideoRequest.newBuilder()
.setInputUri(gcsUri)
.addFeatures(Feature.SHOT_CHANGE_DETECTION)
.build();
// Create an operation that will contain the response when the operation completes.
OperationFuture<AnnotateVideoResponse, AnnotateVideoProgress> response =
client.annotateVideoAsync(request);
System.out.println("Waiting for operation to complete...");
// Print detected shot changes and their location ranges in the analyzed video.
for (VideoAnnotationResults result : response.get().getAnnotationResultsList()) {
if (result.getShotAnnotationsCount() > 0) {
System.out.println("Shots: ");
for (VideoSegment segment : result.getShotAnnotationsList()) {
double startTime =
segment.getStartTimeOffset().getSeconds()
+ segment.getStartTimeOffset().getNanos() / 1e9;
double endTime =
segment.getEndTimeOffset().getSeconds()
+ segment.getEndTimeOffset().getNanos() / 1e9;
System.out.printf("Location: %.3f:%.3f\n", startTime, endTime);
}
} else {
System.out.println("No shot changes detected in " + gcsUri);
}
}
}Node.js
// Imports the Google Cloud Video Intelligence library
const video = require('@google-cloud/video-intelligence').v1;
// Creates a client
const client = new video.VideoIntelligenceServiceClient();
/**
* TODO(developer): Uncomment the following line before running the sample.
*/
// const gcsUri = 'GCS URI of file to analyze, e.g. gs://my-bucket/my-video.mp4';
const request = {
inputUri: gcsUri,
features: ['SHOT_CHANGE_DETECTION'],
};
// Detects camera shot changes
const [operation] = await client.annotateVideo(request);
console.log('Waiting for operation to complete...');
const [operationResult] = await operation.promise();
// Gets shot changes
const shotChanges = operationResult.annotationResults[0].shotAnnotations;
console.log('Shot changes:');
if (shotChanges.length === 1) {
console.log('The entire video is one shot.');
} else {
shotChanges.forEach((shot, shotIdx) => {
console.log(`Scene ${shotIdx} occurs from:`);
if (shot.startTimeOffset === undefined) {
shot.startTimeOffset = {};
}
if (shot.endTimeOffset === undefined) {
shot.endTimeOffset = {};
}
if (shot.startTimeOffset.seconds === undefined) {
shot.startTimeOffset.seconds = 0;
}
if (shot.startTimeOffset.nanos === undefined) {
shot.startTimeOffset.nanos = 0;
}
if (shot.endTimeOffset.seconds === undefined) {
shot.endTimeOffset.seconds = 0;
}
if (shot.endTimeOffset.nanos === undefined) {
shot.endTimeOffset.nanos = 0;
}
console.log(
`\tStart: ${shot.startTimeOffset.seconds}` +
`.${(shot.startTimeOffset.nanos / 1e6).toFixed(0)}s`
);
console.log(
`\tEnd: ${shot.endTimeOffset.seconds}.` +
`${(shot.endTimeOffset.nanos / 1e6).toFixed(0)}s`
);
});
}
PHP
use Google\Cloud\VideoIntelligence\V1\VideoIntelligenceServiceClient;
use Google\Cloud\VideoIntelligence\V1\Feature;
/** Uncomment and populate these variables in your code */
// $uri = 'The cloud storage object to analyze (gs://your-bucket-name/your-object-name)';
// $options = [];
# Instantiate a client.
$video = new VideoIntelligenceServiceClient();
# Execute a request.
$features = [Feature::SHOT_CHANGE_DETECTION];
$operation = $video->annotateVideo([
'inputUri' => $uri,
'features' => $features,
]);
# Wait for the request to complete.
$operation->pollUntilComplete($options);
# Print the result.
if ($operation->operationSucceeded()) {
$results = $operation->getResult()->getAnnotationResults()[0];
foreach ($results->getShotAnnotations() as $shot) {
$start = $shot->getStartTimeOffset();
$end = $shot->getEndTimeOffset();
printf('Shot: %ss to %ss' . PHP_EOL,
$start->getSeconds() + $start->getNanos() / 1000000000.0,
$end->getSeconds() + $end->getNanos() / 1000000000.0);
}
} else {
print_r($operation->getError());
}Python
""" Detects camera shot changes. """
video_client = videointelligence.VideoIntelligenceServiceClient()
features = [videointelligence.Feature.SHOT_CHANGE_DETECTION]
operation = video_client.annotate_video(
request={"features": features, "input_uri": path}
)
print("\nProcessing video for shot change annotations:")
result = operation.result(timeout=90)
print("\nFinished processing.")
# first result is retrieved because a single video was processed
for i, shot in enumerate(result.annotation_results[0].shot_annotations):
start_time = (
shot.start_time_offset.seconds + shot.start_time_offset.microseconds / 1e6
)
end_time = (
shot.end_time_offset.seconds + shot.end_time_offset.microseconds / 1e6
)
print("\tShot {}: {} to {}".format(i, start_time, end_time))A seguir
Para pesquisar e filtrar exemplos de código de outros produtos do Google Cloud, consulte o navegador de exemplos do Google Cloud.