Para criar um controller no laravel, utilize a seguinte sintaxe:
php artisan make:controller <nomecontroller>
Os controller serão criados na pasta:
.\app\Http\Controllers
Conforme o exemplo abaixo:
<?php
namespace App\Http\Controllers;
use Illuminate\Http\Request;
class welcomeController extends Controller
{
//Metodo de visualização
public function welcome(){
return view('welcome');
}
}
É necessário criar o mesmo na rota (web.php):
<?php
use Illuminate\Support\Facades\Route;
use App\Http\Controllers\WelcomeController;
Route::get('/', function () {
$controller = new welcomeController();
return $controller->welcome();
});
Sendo os 3 pacotes iniciais, apenas apoio, e o libfreenect-dev realmente a lib necessária.
Hello World da Biblioteca
Neste primeiro projeto, pouca coisa faremos, apenas iremos compilar identificando o device.
#include <stdio.h>
#include <stdlib.h>
#include <libfreenect.h>
freenect_context *f_ctx;
freenect_device *f_dev;
int user_device_number = 0; // Normalmente 0 se você tiver apenas um Kinect
void depth_cb(freenect_device *dev, void *v_depth, uint32_t timestamp) {
// Callback para dados de profundidade - não usado neste exemplo
}
void rgb_cb(freenect_device *dev, void *rgb, uint32_t timestamp) {
// Salva uma imagem RGB capturada pelo Kinect
FILE *image = fopen("output_image.ppm", "wb");
if (image == NULL) {
printf("Erro ao abrir o arquivo para escrita\n");
return;
}
fprintf(image, "P6\n# Kinect RGB test\n640 480\n255\n");
fwrite(rgb, 640*480*3, 1, image);
fclose(image);
printf("Imagem salva como output_image.ppm\n");
// Depois de salvar a imagem, podemos sair do loop principal
freenect_stop_video(dev);
freenect_close_device(dev);
freenect_shutdown(f_ctx);
exit(0);
}
int main() {
if (freenect_init(&f_ctx, NULL) < 0) {
printf("freenect_init() falhou\n");
return 1;
}
if (freenect_open_device(f_ctx, &f_dev, user_device_number) < 0) {
printf("Não foi possível abrir o dispositivo\n");
freenect_shutdown(f_ctx);
return 1;
}
freenect_set_depth_callback(f_dev, depth_cb);
freenect_set_video_callback(f_dev, rgb_cb);
freenect_set_video_mode(f_dev, freenect_find_video_mode(FREENECT_RESOLUTION_MEDIUM, FREENECT_VIDEO_RGB));
freenect_start_video(f_dev);
while (freenect_process_events(f_ctx) >= 0) {
// Processa eventos do Kinect até que a captura de imagem seja concluída
}
return 0;
}
Neste exemplo o programa pega o kinect e tira uma foto, salvando na maquina local.
Vamos entender o código.
A freenect_init inicia a api.
A próxima função freenect_open_device, abre o device conforme o número que estiver descrito. Isso permite abrir mais de um kinect na mesma maquina.
As funções freenect_set_depth_callback e freenect_set_video_callback criam funções de callback, para controle, se voce não sabe o que é leia este artigo:
Perceba aqui que o pulo do gato neste makefile, é a inclusão da pasta /usr/lib/x86_64-linux-gnu que é onde a lib se encontra. Bem como a /usr/include/libfreenect que é onde o header se encontra.
Compilando o projeto
Para compilar esse projeto, é necessário apenas rodar o script na pasta src do ubuntu:
make all
Compilando o projeto
Rodando o programa
Agora iremos rodar o programa, isso é a parte mais simples.
Ao rodar, ele captura uma foto, e salva, conforme apresentado.
Reconhecimento de voz usando o srvOuve, permite ouvir o que se diz.
O srvOuve, é um projeto de minha autoria, que permite criar aplicação de Voz para Texto. Neste projeto, iremos utilizar várias abordagens diferentes, para criar uma aplicação para atender essa finalidade.
Neste primeiro projeto finalizado, criamos um serviço de voz para texto que precisa ser online.
O projeto srvOuve, permite utilizar diversos serviços diferentes, ouvindo tanto online como offline, unificando assim a forma de obter esses serviços em um único canal.
Permitindo criar integrações mais ageis.
No exemplo do vídeo usamos o MNote como ferramenta de integração. Onde ele recebe o texto “escutado” pelo srvOuve e repassa ao CHATGPT, permitindo assim que esse responda, e depois convertendo em texto de voz, através do srvFalar, outro projeto de minha autoria.
Este é um roteiro de instalação e preparação do seu UBUNTU para rodar o kinect.
O Kinect é parte integrante do XBOX 365, que apesar de já bem antigo (2024) ainda é uma tecnologia disruptiva, trazendo muitos benefícios para quem trabalha com IA e processamento de imagem.
O intuito deste tutorial é demonstrar o que é necessário para rodar o kinect no PC com linux.
Hardware
Logicamente, o kinect 365 é necessário.
Porem não somente ele, o hardware foi construído para o XBOX e possui um conector proprietário, que precisa alem de um adaptador, também de fonte externa para o PC.
Voce pode facilmente encontrar este adaptador se procurar “adaptador kinect xbox PC” em qualquer site de compras.
Software
Existe um pacote para linux que permite rodar o kinect, é o libfreenect.
Se olharmos na lista de repositórios do ubuntu por freenect, encontraremos os seguintes pacotes:
freenect – library for accessing Kinect device — metapackage
libfreenect-bin – library for accessing Kinect device — utilities and samples
libfreenect-demos -library for accessing Kinect device — dummy package
libfreenect-dev – library for accessing Kinect device — development files
libfreenect-doc – library for accessing Kinect device — documentation
libfreenect0.5 – library for accessing Kinect device
Para instalar esses pacotes siga o roteiro, instalando primeiro os pacotes requeridos.
Existe um conjunto de demos que foram criados para permitir usar o kinect. Vamos entender cada um.
freenect-camtest: Uma ferramenta de teste para verificar o funcionamento básico das câmeras RGB e de profundidade do Kinect.
freenect-chunkview: Utilitário para visualizar dados de “chunk” (pedaço), útil para debugar ou entender como os dados são transferidos do Kinect.
freenect-cpp_pcview: Um visualizador de nuvem de pontos escrito em C++, demonstrando como processar e visualizar dados de profundidade em 3D.
freenect-cppview: Similar ao freenect-cpp_pcview, oferece uma visualização básica da saída RGB e de profundidade usando C++.
freenect-glview: Provavelmente um dos exemplos mais usados, oferece uma visualização ao vivo simples das câmeras RGB e de profundidade usando OpenGL.
freenect-glpclview: Uma ferramenta avançada para visualizar a saída do Kinect como uma nuvem de pontos 3D, utilizando a biblioteca PCL (Point Cloud Library) e OpenGL para renderização.
freenect-hiview: Uma ferramenta de visualização que pode ser usada para exibir dados de alta resolução do Kinect.
Teste com freenect-glview
Demonstra o uso do kinect.
No nosso próximo artigo, irei demonstrar o uso do kinect, e fazer um exemplo de código em C.
Baixe o instalador assistido para seu sistema operacional
Baixe o compilador da sua plataforma
Execute o instalador, e aguarde o processo de instalação.
Após a instalação, rode o programa
cargo –version
teste do rust instalado
Após a sua instalação, o mesmo deve ser mostrado conforme apresentado.
Crie um hello world.rs
// This is a comment, and is ignored by the compiler.
// You can test this code by clicking the "Run" button over there ->
// or if you prefer to use your keyboard, you can use the "Ctrl + Enter"
// shortcut.
// This code is editable, feel free to hack it!
// You can always return to the original code by clicking the "Reset" button ->
// This is the main function.
fn main() {
// Statements here are executed when the compiled binary is called.
// Print text to the console.
println!("Hello World!");
}
Pronto agora é só salvar na maquina.
Agora iremos criar o projeto
cargo init hello
Cria o projeto do rust
Será criado uma pasta com o mesmo nome do projeto.
