Utiliser un Text To Speech.

Salut, je dois faire un logiciel pour ma tante anglophone mal-voyante (en fait l'ideal serait de lui faire une Appli android mais n'ayant aucune experience sur Android je vais deja essayé sur PC.)

J'ai besoin pour cela d'un Text To Speech qui sort une voix qui n'est pas robotisée et si possible pas trop desagrable. Le seul convenable et gratuit que j'ai trouvé c'est ici: http://ttsreader.com/ (si vous avez un encore meilleur TTS anglophone a me conseillé je reste preneur.)

Sauf que ce site ne propose pour l'instant qu'une API en javascript pour le speech recognition (ici => https://speechlogger.appspot.com/developers/ ).

J'ai contacté le developpeur par mail pour savoir si je pouvais utiliser son TTS dans une appli JAVA et si oui comment faire. Il m'a dit qu'une API pour le TTS arriverait "bientot" et que si je ne voulais pas attendre je pouvais d'hors et deja le faire sans API en me referent a son appli: https://play.google.com/store/apps/d...gger.ttsreader ).

Sauf que je ne sais pas comment le faire par moi même :/

Je me pose quelques questions. Deja je suppose que son API pour le TTS sera comparable a celle pour le speech recognition du coup en Javascript. Si oui ça ne posera pas de problème pour l'integrer a du JAVA ? (que ça soit pour un software PC ou pour une appli Android ?)

Ensuite, comment pourrais-je faire tout ça par moi même en attendant que son API sorte ? Car son API pour le SR date quand même de 2012. Je sens bien que l'API TTS c'est pas pour tout d'suite.

Bonjour,
tu peux exécuter du code JavaScript dans Java car la JVM dispose depuis quelques versions déjà (depuis Java 6 en fait) d'un interpréteur JavaScript.

Si c'est du code/une lib qui doit être intégré à une page web, JavaFX permet d'afficher ce genre de pages dans un contrôle nommé WebView et il est possible de créer des ponts entre le code Java et le code JavaScript.

Après bien sur il faudra quand même vérifier que cela fonctionne et qu'il n'y a pas d’incompatibilités*. À tester donc.

*Il est possible que l'API Web Speech, même si c'est un standard, ne soit pas supportée et je n'ai aucune idée de comment une page web intégrée dans un contrôle FX peut capturer, ou obtenir la permission de capturer ou même si c'est possible, le son du microphone.

Accessoirement, pour le speech recognition, il existe des API Java également : Sphinx, mais je ne les ai jamais utilisées.

Pour Android, il est possible que Google fournisse déjà une API ou quelque chose qui permette de le faire également.

Je viens de faire un petit test avec Shinx, ça marche mais je trouve que les résultats sont souvent assez catastrophiques (y a probablement besoin de faire du treaning pour améliorer les choses, je pense) et surtout c'est quand même long a se mettre en place pour la capture (y doit probablement y avoir des moyens d’accélérer le warmup de l'API et de la reconnaissance) :

pom.xml (PS : j'ai utilisé la version stable présente sur Maven Central et non pas la version alpha indiquée sur sonatype dans la doc linkée plus haut)

Code:

1
2
3
4
5
6
7
8
9
10
11
12
    <dependencies>
        <dependency>
            <groupId>de.sciss</groupId>
            <artifactId>sphinx4-core</artifactId>
            <version>1.0.0</version>
        </dependency>        
        <dependency>
            <groupId>de.sciss</groupId>
            <artifactId>sphinx4-data</artifactId>
            <version>1.0.0</version>
        </dependency>
    </dependencies>

Et l'application JavaFX.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
package test.spinxfx;
 
import edu.cmu.sphinx.api.Configuration;
import edu.cmu.sphinx.api.LiveSpeechRecognizer;
import edu.cmu.sphinx.api.SpeechResult;
import edu.cmu.sphinx.linguist.dictionary.Word;
import edu.cmu.sphinx.result.WordResult;
import java.util.stream.Collectors;
import javafx.application.Application;
import javafx.concurrent.Service;
import javafx.concurrent.Task;
import javafx.geometry.Insets;
import javafx.scene.Scene;
import javafx.scene.control.Button;
import javafx.scene.control.TextArea;
import javafx.scene.layout.HBox;
import javafx.scene.layout.Priority;
import javafx.scene.layout.VBox;
import javafx.stage.Stage;
 
public class Main extends Application {
 
    private Configuration configuration;
    private LiveSpeechRecognizer recognizer;
 
    @Override
    public void init() throws Exception {
        configuration = new Configuration();
        configuration.setAcousticModelPath("resource:/edu/cmu/sphinx/models/en-us/en-us"); // NOI18N.
        configuration.setDictionaryPath("resource:/edu/cmu/sphinx/models/en-us/cmudict-en-us.dict"); // NOI18N.
        configuration.setLanguageModelPath("resource:/edu/cmu/sphinx/models/en-us/en-us.lm.bin"); // NOI18N.
        recognizer = new LiveSpeechRecognizer(configuration);
    }
 
    private TextArea textToSayArea;
    private Button speechButton;
    private Button captureButton;
    private TextArea textCapturedArea;
 
    @Override
    public void start(Stage stage) throws Exception {
        textToSayArea = new TextArea();
        textToSayArea.setPromptText("Text to synthesize");
        VBox.setVgrow(textToSayArea, Priority.ALWAYS);
        //
        textCapturedArea = new TextArea();
        textCapturedArea.setEditable(false);
        textCapturedArea.setPromptText("Text captured");
        VBox.setVgrow(textCapturedArea, Priority.ALWAYS);
        //
        speechButton = new Button("Say");
        speechButton.setOnAction(actionEvent -> synthesizeText());
        captureButton = new Button("Capture");
        captureButton.setOnAction(actionEvent -> captureSpeech());
        final HBox buttonBox = new HBox();
        buttonBox.setSpacing(6);
        buttonBox.getChildren().setAll(speechButton, captureButton);
        VBox.setVgrow(buttonBox, Priority.NEVER);
        //
        final VBox root = new VBox();
        root.setSpacing(6);
        root.setPadding(new Insets(6));
        root.setFillWidth(true);
        root.getChildren().setAll(textToSayArea, buttonBox, textCapturedArea);
        final Scene scene = new Scene(root);
        stage.setTitle("JavaFX and Sphinx");
        stage.setScene(scene);
        stage.show();
    }
 
    private void synthesizeText() {
        String textToSay = textToSayArea.getText();
        textToSay = (textToSay == null) ? "" : textToSay.trim(); // NOI18N.
        if (textToSay.isEmpty()) {
            // @todo Do stuff!
        }
    }
 
    private Service<SpeechResult> captureService;
 
    private void captureSpeech() {
        captureButton.setDisable(true);
        textCapturedArea.setText(null);
        if (captureService == null) {
            captureService = new Service<SpeechResult>() {
                @Override
                protected Task<SpeechResult> createTask() {
                    return new SpeechCaptureTask();
                }
            };
            captureService.setOnSucceeded(workerStateEvent -> {
                final SpeechResult result = (SpeechResult) workerStateEvent.getSource().getValue();
                dealWithSpeechResult(result);
            });
            captureService.setOnCancelled(workerStateEvent -> {
                captureButton.setDisable(false);
            });
            captureService.setOnFailed(workerStateEvent -> {
                captureButton.setDisable(false);
            });
        }
        captureService.restart();
    }
 
    private final class SpeechCaptureTask extends Task<SpeechResult> {
 
        @Override
        protected SpeechResult call() throws Exception {
            recognizer.startRecognition(true);
            final SpeechResult result = recognizer.getResult();
            recognizer.stopRecognition();
            return result;
        }
    }
 
    private void dealWithSpeechResult(final SpeechResult result) {
        System.out.println("==== Got a result! ==="); // NOI18N.
        System.out.println(result.getHypothesis());
        final String sentence = result.getWords()
                .stream()
                .map(WordResult::getWord)
                .map(Word::toString)
                .collect(Collectors.joining(" ", "", "")); // NOI18N.
        textCapturedArea.setText(sentence);
        captureButton.setDisable(false);
    }
 
    public static void main(String[] args) {
        launch(args);
    }
}

Vu la lenteur de réaction de l'API, j'ai mis le tout dans une tache de fond (d’où la présence du Service/Task pour éviter de bloquer l'UI). Il manque bien sur la partie synthèse puisque Sphinx ne fait que de la reconnaissance (je crois).