import com.google.api.services.vision.v1.model.EntityAnnotation; //导入依赖的package包/类
private String convertResponseToStringLabel(BatchAnnotateImagesResponse response) {

        String message = "I found these things!!!!!!!!:\n\n";
        java.util.List<EntityAnnotation> annotations = response.getResponses().get(0).getLabelAnnotations();
        if (annotations != null) {
            System.out.println("Entity:Score");
            System.out.println("===============");
            for (EntityAnnotation entity : annotations) {
                message += String.format(Locale.KOREAN, "%.3f: %s", entity.getScore(), entity.getDescription());
                message += "\n";
                System.out.println(entity.getDescription() + " : " + entity.getScore());
            }
        } else {
            message += "nothing";
        }

        return message;
    }
 

import com.google.api.services.vision.v1.model.EntityAnnotation; //导入依赖的package包/类
private GoogleVisionApiResponse handleResponse(BatchAnnotateImagesResponse batchResponse) {
    GoogleVisionApiResponse result = new GoogleVisionApiResponse();
    for (int i = 0; i < requestFiles.size(); i++) {
        GoogleVisionApiRequestFile file = requestFiles.get(i);
        AnnotateImageResponse annotateImageResponse = batchResponse.getResponses().get(i);
        List<EntityAnnotation> entityAnnotations =
                MoreObjects.firstNonNull(
                        annotateImageResponse.getTextAnnotations(),
                        ImmutableList.<EntityAnnotation>of());

        entityAnnotations.stream()
                .findFirst()
                .ifPresent(a -> {
                    result.addDescription(file.getFileId(), a.getDescription());
                });
    }
    return result;
}
 

import com.google.api.services.vision.v1.model.EntityAnnotation; //导入依赖的package包/类
/**
 * Annotates an image using the Vision API.
 */
public static void main(String[] args) throws IOException, GeneralSecurityException {
  if (args.length != 1) {
    System.err.println("Usage:");
    System.err.printf("\tjava %s gs://<bucket_name>/<object_name>\n",
        DetectLandmark.class.getCanonicalName());
    System.exit(1);
  } else if (!args[0].toLowerCase().startsWith("gs://")) {
    System.err.println("Google Cloud Storage url must start with 'gs://'.");
    System.exit(1);
  }

  DetectLandmark app = new DetectLandmark(getVisionService());
  List<EntityAnnotation> landmarks = app.identifyLandmark(args[0], MAX_RESULTS);
  System.out.printf("Found %d landmark%s\n", landmarks.size(), landmarks.size() == 1 ? "" : "s");
  for (EntityAnnotation annotation : landmarks) {
    System.out.printf("\t%s\n", annotation.getDescription());
  }
}
 

import com.google.api.services.vision.v1.model.EntityAnnotation; //导入依赖的package包/类
@Test public void printLabels_manyLabels_printsLabels() throws Exception {
  // Arrange
  ByteArrayOutputStream bout = new ByteArrayOutputStream();
  PrintStream out = new PrintStream(bout);
  ImmutableList<EntityAnnotation> labels =
      ImmutableList.of(
          new EntityAnnotation().setDescription("dog").setScore(0.7564f),
          new EntityAnnotation().setDescription("husky").setScore(0.67891f),
          new EntityAnnotation().setDescription("poodle").setScore(0.1233f));

  // Act
  LabelApp.printLabels(out, Paths.get("path/to/some/image.jpg"), labels);

  // Assert
  String got = bout.toString();
  assertThat(got).contains("dog (score: 0.756)");
  assertThat(got).contains("husky (score: 0.679)");
  assertThat(got).contains("poodle (score: 0.123)");
}
 

import com.google.api.services.vision.v1.model.EntityAnnotation; //导入依赖的package包/类
/**
 * Gets up to {@code maxResults} labels for an image stored at {@code path}.
 * @param path p
 * @param maxResults m 
 * @return list of entity annotations
 * @throws IOException e
 */
public List<EntityAnnotation> labelImage(Path path, int maxResults) throws IOException {
  // [START construct_request]
  byte[] data = Files.readAllBytes(path);

  AnnotateImageRequest request = new AnnotateImageRequest().setImage(new Image().encodeContent(data))
      .setFeatures(ImmutableList.of(new Feature().setType("LABEL_DETECTION").setMaxResults(maxResults)));
  Vision.Images.Annotate annotate = vision.images().annotate(new BatchAnnotateImagesRequest().setRequests(ImmutableList.of(request)));
  // Due to a bug: requests to Vision API containing large images fail
  // when GZipped.
  // annotate.setDisableGZipContent(true);
  // [END construct_request]

  // [START parse_response]
  BatchAnnotateImagesResponse batchResponse = annotate.execute();
  assert batchResponse.getResponses().size() == 1;
  AnnotateImageResponse response = batchResponse.getResponses().get(0);
  if (response.getLabelAnnotations() == null) {
    throw new IOException(response.getError() != null ? response.getError().getMessage() : "Unknown error getting image annotations");
  }
  return response.getLabelAnnotations();
  // [END parse_response]
}
 

import com.google.api.services.vision.v1.model.EntityAnnotation; //导入依赖的package包/类
/**
 * Process an encoded image and return a collection of vision
 * annotations describing features of the image data.
 *
 * @return collection of annotation descriptions and scores.
 */
private static Map<String, Float> convertResponseToMap(BatchAnnotateImagesResponse response) {

    // Convert response into a readable collection of annotations
    Map<String, Float> annotations = new HashMap<>();
    List<EntityAnnotation> labels = response.getResponses().get(0).getLabelAnnotations();
    if (labels != null) {
        for (EntityAnnotation label : labels) {
            annotations.put(label.getDescription(), label.getScore());
        }
    }

    Log.d(TAG, "Cloud Vision request completed:" + annotations);
    return annotations;
}
 

import com.google.api.services.vision.v1.model.EntityAnnotation; //导入依赖的package包/类
private List<String> convertResponseToList(BatchAnnotateImagesResponse response) {
    List<String> res = new ArrayList<>();
    List<EntityAnnotation> labels = response.getResponses().get(0).getLabelAnnotations();
    if (labels != null) {
        for (EntityAnnotation label : labels) {
            res.add(label.getDescription());
        }
    }
    return res;
}
 

import com.google.api.services.vision.v1.model.EntityAnnotation; //导入依赖的package包/类
/**
 * Gets up to {@code maxResults} landmarks for an image stored at {@code uri}.
 */
public List<EntityAnnotation> identifyLandmark(String uri, int maxResults) throws IOException {
  AnnotateImageRequest request =
      new AnnotateImageRequest()
          .setImage(new Image().setSource(
              new ImageSource().setGcsImageUri(uri)))
          .setFeatures(ImmutableList.of(
              new Feature()
                  .setType("LANDMARK_DETECTION")
                  .setMaxResults(maxResults)));
  Vision.Images.Annotate annotate =
      vision.images()
          .annotate(new BatchAnnotateImagesRequest().setRequests(ImmutableList.of(request)));
  // Due to a bug: requests to Vision API containing large images fail when GZipped.
  annotate.setDisableGZipContent(true);

  BatchAnnotateImagesResponse batchResponse = annotate.execute();
  assert batchResponse.getResponses().size() == 1;
  AnnotateImageResponse response = batchResponse.getResponses().get(0);
  if (response.getLandmarkAnnotations() == null) {
    throw new IOException(
        response.getError() != null
            ? response.getError().getMessage()
            : "Unknown error getting image annotations");
  }
  return response.getLandmarkAnnotations();
}
 

import com.google.api.services.vision.v1.model.EntityAnnotation; //导入依赖的package包/类
@Test public void identifyLandmark_withLandmark_returnsKnownLandmark() throws Exception {
  List<EntityAnnotation> landmarks = appUnderTest.identifyLandmark(LANDMARK_URI, MAX_RESULTS);

  assertThat(landmarks).named("water.jpg landmarks").isNotEmpty();
  assertThat(landmarks.get(0).getDescription())
      .named("water.jpg landmark #0 description")
      .isEqualTo("Taitung, Famous Places \"up the water flow\" marker");
}
 

import com.google.api.services.vision.v1.model.EntityAnnotation; //导入依赖的package包/类
/**
 * Extracts as a combinded string, all the descriptions from text annotations on an {@code image}.
 */
public Word extractDescriptions(ImageText image) {
  String document = "";
  for (EntityAnnotation text : image.textAnnotations()) {
    document += text.getDescription();
  }
  if (document.equals("")) {
    System.out.printf("%s had no discernible text.\n", image.path());
  }
  // Output a progress indicator.
  System.out.print('.');
  System.out.flush();
  return Word.builder().path(image.path()).word(document).build();
}
 

import com.google.api.services.vision.v1.model.EntityAnnotation; //导入依赖的package包/类
/**
 * Prints the labels received from the Vision API.
 */
public static void printLabels(PrintStream out, Path imagePath, List<EntityAnnotation> labels) {
  out.printf("Labels for image %s:\n", imagePath);
  for (EntityAnnotation label : labels) {
    out.printf(
        "\t%s (score: %.3f)\n",
        label.getDescription(),
        label.getScore());
  }
  if (labels.isEmpty()) {
    out.println("\tNo labels found.");
  }
}
 

import com.google.api.services.vision.v1.model.EntityAnnotation; //导入依赖的package包/类
/**
 * Gets up to {@code maxResults} labels for an image stored at {@code path}.
 */
public List<EntityAnnotation> labelImage(Path path, int maxResults) throws IOException {
  // [START construct_request]
  byte[] data = Files.readAllBytes(path);

  AnnotateImageRequest request =
      new AnnotateImageRequest()
          .setImage(new Image().encodeContent(data))
          .setFeatures(ImmutableList.of(
              new Feature()
                  .setType("LABEL_DETECTION")
                  .setMaxResults(maxResults)));
  Vision.Images.Annotate annotate =
      vision.images()
          .annotate(new BatchAnnotateImagesRequest().setRequests(ImmutableList.of(request)));
  // Due to a bug: requests to Vision API containing large images fail when GZipped.
  annotate.setDisableGZipContent(true);
  // [END construct_request]

  // [START parse_response]
  BatchAnnotateImagesResponse batchResponse = annotate.execute();
  assert batchResponse.getResponses().size() == 1;
  AnnotateImageResponse response = batchResponse.getResponses().get(0);
  if (response.getLabelAnnotations() == null) {
    throw new IOException(
        response.getError() != null
            ? response.getError().getMessage()
            : "Unknown error getting image annotations");
  }
  return response.getLabelAnnotations();
  // [END parse_response]
}
 

import com.google.api.services.vision.v1.model.EntityAnnotation; //导入依赖的package包/类
@Test public void labelImage_cat_returnsCatDescription() throws Exception {
  List<EntityAnnotation> labels =
      appUnderTest.labelImage(Paths.get("data/cat.jpg"), MAX_LABELS);

  ImmutableSet.Builder<String> builder = ImmutableSet.builder();
  for (EntityAnnotation label : labels) {
    builder.add(label.getDescription());
  }
  ImmutableSet<String> descriptions = builder.build();

  assertThat(descriptions).named("cat.jpg labels").contains("cat");
}
 

import com.google.api.services.vision.v1.model.EntityAnnotation; //导入依赖的package包/类
@Test public void printLabels_emptyList_printsNoLabelsFound() throws Exception {
  // Arrange
  ByteArrayOutputStream bout = new ByteArrayOutputStream();
  PrintStream out = new PrintStream(bout);

  // Act
  LabelApp.printLabels(
      out, Paths.get("path/to/some/image.jpg"), ImmutableList.<EntityAnnotation>of());

  // Assert
  assertThat(bout.toString()).contains("No labels found.");
}
 

import com.google.api.services.vision.v1.model.EntityAnnotation; //导入依赖的package包/类
/**
 * Prints the labels received from the Vision API.
 * @param out o
 * @param imagePath i 
 * @param labels l
 */
public void printLabels(PrintStream out, Path imagePath, List<EntityAnnotation> labels) {
  out.printf("Labels for image %s:\n", imagePath);
  for (EntityAnnotation label : labels) {
    out.printf("\t%s (score: %.3f)\n", label.getDescription(), label.getScore());
  }
  if (labels.isEmpty()) {
    out.println("\tNo labels found.");
  }
}
 

import com.google.api.services.vision.v1.model.EntityAnnotation; //导入依赖的package包/类
@Test
    public void testTextDetection() throws Exception {

        // 認証情報
        GoogleCredential credential = GoogleCredential.fromStream(
                    Files.newInputStream(Paths.get("/tmp/google-cloud-api-service-account.json")))
                    .createScoped(VisionScopes.all());
//        GoogleCredential credential = GoogleCredential.getApplicationDefault().createScoped(VisionScopes.all());

        // Google Cloud Vision APIクライアント
        Vision vision = new Vision.Builder(GoogleNetHttpTransport.newTrustedTransport(), JacksonFactory.getDefaultInstance(), credential)
                .setApplicationName("GoogleVisionApiClient/1.0")
                .build();

        // 解析対象画像ファイルごとに処理を行う
        ImmutableList<String> imageFiles = ImmutableList.<String>of(
                "/tmp/sample1.jpg",
                "/tmp/sample2.jpg",
                "/tmp/sample3.jpg",
                "/tmp/sample4.jpg"
                );
        ImmutableList.Builder<AnnotateImageRequest> requests = ImmutableList.builder();
        imageFiles.forEach(f -> {
            byte[] data = new byte[0];
            try {
                data = Files.readAllBytes(Paths.get(f));
                requests.add(
                        new AnnotateImageRequest()
                                .setImage(new Image().encodeContent(data))
                                .setFeatures(ImmutableList.of(
                                        new Feature()
                                                .setType("TEXT_DETECTION")
                                                .setMaxResults(1)
                                ))
                );
            } catch (IOException e) {
                e.printStackTrace();
            }
        });

        // 実行
        Vision.Images.Annotate annotate =
                vision.images().annotate(new BatchAnnotateImagesRequest().setRequests(requests.build()));
        annotate.setDisableGZipContent(true);
        BatchAnnotateImagesResponse batchResponse = annotate.execute();

        batchResponse.getResponses().forEach(response -> {
            List<EntityAnnotation> entityAnnotations =
                    MoreObjects.firstNonNull(response.getTextAnnotations(), ImmutableList.<EntityAnnotation>of());
            entityAnnotations.stream()
                    .findFirst()
                    .ifPresent(a -> {
                        System.out.println(a.getDescription());
                        System.out.println("----------------------------------------------------");
                    });
        });
    }
 

import com.google.api.services.vision.v1.model.EntityAnnotation; //导入依赖的package包/类
private String convertResponseToString(BatchAnnotateImagesResponse response) {
    StringBuilder message = new StringBuilder("Results:\n\n");
    message.append("Labels:\n");
    List<EntityAnnotation> labels = response.getResponses().get(0).getLabelAnnotations();
    if (labels != null) {
        for (EntityAnnotation label : labels) {
            message.append(String.format(Locale.getDefault(), "%.3f: %s",
                    label.getScore(), label.getDescription()));
            message.append("\n");
        }
    } else {
        message.append("nothing\n");
    }

    message.append("Texts:\n");
    List<EntityAnnotation> texts = response.getResponses().get(0)
            .getTextAnnotations();
    if (texts != null) {
        for (EntityAnnotation text : texts) {
            message.append(String.format(Locale.getDefault(), "%s: %s",
                    text.getLocale(), text.getDescription()));
            message.append("\n");
        }
    } else {
        message.append("nothing\n");
    }

    message.append("Landmarks:\n");
    List<EntityAnnotation> landmarks = response.getResponses().get(0)
            .getLandmarkAnnotations();
    if (landmarks != null) {
        for (EntityAnnotation landmark : landmarks) {
            message.append(String.format(Locale.getDefault(), "%.3f: %s",
                    landmark.getScore(), landmark.getDescription()));
            message.append("\n");
        }
    } else {
        message.append("nothing\n");
    }

    return message.toString();
}
 

import com.google.api.services.vision.v1.model.EntityAnnotation; //导入依赖的package包/类
public List<EntityAnnotation> textAnnotations() {
  return this.ts;
}