You can not select more than 25 topics
			Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
		
		
		
		
		
			
		
			
				
					
					
						
							76 lines
						
					
					
						
							3.4 KiB
						
					
					
				
			
		
		
		
			
			
			
				
					
				
				
					
				
			
		
		
	
	
							76 lines
						
					
					
						
							3.4 KiB
						
					
					
				
								//
							 | 
						|
								// Created by 14727 on 2022/11/19.
							 | 
						|
								//
							 | 
						|
								
							 | 
						|
								#include "device/Nurbs/nurbs_common.cuh"
							 | 
						|
								#include "device/device_utils.cuh"
							 | 
						|
								#include <cstdio>
							 | 
						|
								
							 | 
						|
								__device__ void d_basisFunction(float *N_Texture, const float *knots, float u, int degree, int d_knotsCnt) {
							 | 
						|
								    int m = d_knotsCnt - 1;
							 | 
						|
								    for (int p = 0; p <= degree; p++) {
							 | 
						|
								        for (int i = 0; i + p <= m - 1; i++) {
							 | 
						|
								            if (p == 0) {
							 | 
						|
								                if ((u > knots[i] || d_floatEqual(u, knots[i])) && (u < knots[i + 1])
							 | 
						|
								                    ||
							 | 
						|
								                    d_floatEqual(u, knots[i + 1]) && d_floatEqual(u, knots[m])) {
							 | 
						|
								                    N_Texture[p * m + i] = 1.0;
							 | 
						|
								                } else {
							 | 
						|
								                    N_Texture[p * m + i] = 0.0;
							 | 
						|
								                }
							 | 
						|
								            } else {
							 | 
						|
								                float Nip_1 = N_Texture[(p - 1) * m + i];
							 | 
						|
								                float Ni1p_1 = N_Texture[(p - 1) * m + i + 1];
							 | 
						|
								                float left = d_floatEqual(knots[i + p], knots[i]) ? 0 : (u - knots[i]) * Nip_1 /
							 | 
						|
								                                                                        (knots[i + p] - knots[i]);
							 | 
						|
								                float right = d_floatEqual(knots[i + p + 1], knots[i + 1]) ? 0 : (knots[i + p + 1] - u) * Ni1p_1 /
							 | 
						|
								                                                                                 (knots[i + p + 1] - knots[i + 1]);
							 | 
						|
								                N_Texture[p * m + i] = left + right;
							 | 
						|
								            }
							 | 
						|
								        }
							 | 
						|
								    }
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								__global__ void g_basisTexture(float *nTexture, float *nTexture1, const float *d_knots, int d_pointsCnt, int d_knotsCnt,
							 | 
						|
								                               int d_sampleCnt) {
							 | 
						|
								    // 一维grid和一维block
							 | 
						|
								    int idx = blockIdx.x * blockDim.x + threadIdx.x;  // 采样点编号
							 | 
						|
								    float d_paramCeil = d_knots[d_knotsCnt - 1];
							 | 
						|
								    float u = idx * d_paramCeil / (d_sampleCnt - 1);
							 | 
						|
								    if (u > 1.0 * d_paramCeil) {
							 | 
						|
								        return;
							 | 
						|
								    }
							 | 
						|
								    int d_degree = d_knotsCnt - 1 - d_pointsCnt;
							 | 
						|
								    auto *N_dp = (float *) malloc((d_degree + 1) * (d_knotsCnt - 1) * sizeof(float));
							 | 
						|
								    d_basisFunction(N_dp, d_knots, u, d_degree, d_knotsCnt);
							 | 
						|
								    for (int i = 0; i < d_pointsCnt; i++) {
							 | 
						|
								        nTexture[idx * d_pointsCnt + i] = N_dp[d_degree * (d_knotsCnt - 1) + i];
							 | 
						|
								        nTexture1[idx * (d_pointsCnt + 1) + i] = N_dp[(d_degree - 1) * (d_knotsCnt - 1) + i];
							 | 
						|
								    }
							 | 
						|
								    nTexture1[idx * (d_pointsCnt + 1) + d_pointsCnt] = N_dp[(d_degree - 1) * (d_knotsCnt - 1) +
							 | 
						|
								                                                            d_pointsCnt]; // nTexture1多记录一列数据
							 | 
						|
								    d_safeFree(N_dp);
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								__global__ void
							 | 
						|
								g_derTexture(float *derTexture, const float *nTexture1, const float *d_knots, int d_pointsCnt, int d_knotsCnt,
							 | 
						|
								             int d_sampleCnt) {
							 | 
						|
								    // 一维grid和一维block
							 | 
						|
								    int idx = blockIdx.x * blockDim.x + threadIdx.x;  // 采样点编号
							 | 
						|
								    if (idx >= d_sampleCnt) {
							 | 
						|
								        return;
							 | 
						|
								    }
							 | 
						|
								    int degree = d_knotsCnt - 1 - d_pointsCnt;
							 | 
						|
								
							 | 
						|
								//    printf("degree: %d\n", degree);
							 | 
						|
								    for (int i = 0; i < d_pointsCnt; i++) {
							 | 
						|
								        float left = d_floatEqual(d_knots[i + degree], d_knots[i]) ? 0 :
							 | 
						|
								                     nTexture1[idx * (d_pointsCnt + 1) + i] * (degree - 1) / (d_knots[i + degree] - d_knots[i]);
							 | 
						|
								        float right = d_floatEqual(d_knots[i + degree + 1], d_knots[i + 1]) ? 0 :
							 | 
						|
								                      nTexture1[idx * (d_pointsCnt + 1) + i + 1] * (degree - 1) /
							 | 
						|
								                      (d_knots[i + degree + 1] - d_knots[i + 1]);
							 | 
						|
								        derTexture[idx * d_pointsCnt + i] = left - right;
							 | 
						|
								//        printf("<%d, %d> -- %g \n", idx, i, left - right);
							 | 
						|
								//        printf("nTex1: %g \n", nTexture1[idx * (d_pointsCnt + 1) + i]);
							 | 
						|
								    }
							 | 
						|
								}
							 |