1 /*
2 * Copyright (c) 2024 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15 #include "anisotropic.h"
16 #include <linux/pcitest.h>
17 #include <native_drawing/drawing_color.h>
18 #include <native_drawing/drawing_brush.h>
19 #include <native_drawing/drawing_image.h>
20 #include <native_drawing/drawing_matrix.h>
21 #include <native_drawing/drawing_path.h>
22 #include <native_drawing/drawing_pen.h>
23 #include <native_drawing/drawing_round_rect.h>
24 #include <native_drawing/drawing_round_rect.h>
25 #include <native_drawing/drawing_sampling_options.h>
26 #include <native_drawing/drawing_shader_effect.h>
27 #include <native_drawing/drawing_point.h>
28 #include <native_drawing/drawing_surface.h>
29 #include "test_common.h"
30 #include "common/log_common.h"
31
32 enum SkAlphaType : int {
33 K_UNKNOWN_SK_ALPHA_TYPE, // !< uninitialized
34 K_OPAQUE_SK_ALPHA_TYPE, // !< pixel is opaque
35 K_PREMUL_SK_ALPHA_TYPE, // !< pixel components are premultiplied by alpha
36 K_UNPREMUL_SK_ALPHA_TYPE, // !< pixel components are independent of alpha
37 K_LAST_ENUM_SK_ALPHA_TYPE = K_UNPREMUL_SK_ALPHA_TYPE, // !< last valid value
38 };
39
40 float g_scales[] = {0.9f, 0.8f, 0.75f, 0.6f, 0.5f, 0.4f, 0.25f, 0.2f, 0.1f};
41
~Anisotropic()42 Anisotropic::~Anisotropic() {}
43
DrawImage(OH_Drawing_Canvas * canvas,OH_Drawing_Image * image,OH_Drawing_Bitmap * bitmap)44 void Anisotropic::DrawImage(OH_Drawing_Canvas *canvas, OH_Drawing_Image *image, OH_Drawing_Bitmap *bitmap)
45 {
46 OH_Drawing_SamplingOptions *fsampling = OH_Drawing_SamplingOptionsCreate(OH_Drawing_FilterMode::FILTER_MODE_NEAREST,
47 OH_Drawing_MipmapMode::MIPMAP_MODE_LINEAR);
48 int size = sizeof(g_scales) / sizeof(g_scales[0]);
49 OH_Drawing_CanvasClear(canvas, 0xFFCCCCCC);
50
51 for (int i = 0; i < size; ++i) {
52 int height = (int)(OH_Drawing_BitmapGetHeight(bitmap) * g_scales[i]);
53
54 int yOff;
55 if (i <= size / 2) { // 2cout
56 yOff = kSpacer + i * (OH_Drawing_BitmapGetHeight(bitmap) + kSpacer);
57 } else {
58 yOff = (size - i) * (OH_Drawing_BitmapGetHeight(bitmap) + kSpacer) - height;
59 }
60
61 OH_Drawing_Rect *rect = OH_Drawing_RectCreate((float)kSpacer, (float)yOff,
62 (float)OH_Drawing_BitmapGetWidth(bitmap) + (float)kSpacer, (float)height + (float)yOff);
63 OH_Drawing_CanvasDrawImageRect(canvas, image, rect, fsampling);
64 OH_Drawing_RectDestroy(rect);
65 }
66
67 for (int i = 0; i < size; ++i) {
68 int width = (int)(OH_Drawing_BitmapGetWidth(bitmap) * g_scales[i]);
69
70 int xOff;
71 int yOff;
72 if (i <= size / 2) { // 2被除数
73 xOff = OH_Drawing_BitmapGetWidth(bitmap) + 2 * kSpacer; // 2 cout
74 yOff = kSpacer + i * (OH_Drawing_BitmapGetHeight(bitmap) + kSpacer);
75 } else {
76 xOff = OH_Drawing_BitmapGetWidth(bitmap) + 2 * kSpacer + OH_Drawing_BitmapGetWidth(bitmap) - width; // 2cout
77 yOff = kSpacer + (size - i - 1) * (OH_Drawing_BitmapGetHeight(bitmap) + kSpacer);
78 }
79
80 OH_Drawing_Rect *rect = OH_Drawing_RectCreate((float)xOff, (float)yOff,
81 (float)width + (float)xOff, (float)OH_Drawing_BitmapGetHeight(bitmap) + (float)yOff);
82 OH_Drawing_CanvasDrawImageRect(canvas, image, rect, fsampling);
83 OH_Drawing_RectDestroy(rect);
84 }
85 OH_Drawing_SamplingOptionsDestroy(fsampling);
86 }
87
OnTestFunction(OH_Drawing_Canvas * canvas)88 void Anisotropic::OnTestFunction(OH_Drawing_Canvas *canvas)
89 {
90 OH_Drawing_Bitmap *bitmap = OH_Drawing_BitmapCreate();
91 OH_Drawing_Canvas *bimap_canvas = OH_Drawing_CanvasCreate();
92 OH_Drawing_BitmapFormat cFormat { COLOR_FORMAT_BGRA_8888, ALPHA_FORMAT_OPAQUE };
93 OH_Drawing_BitmapBuild(bitmap, kImageSize, kImageSize, &cFormat);
94 OH_Drawing_CanvasBind(bimap_canvas, bitmap);
95 OH_Drawing_CanvasClear(bimap_canvas, 0xFFFFFFFF);
96 OH_Drawing_Image *image = OH_Drawing_ImageCreate();
97 OH_Drawing_Brush *brush = OH_Drawing_BrushCreate();
98 OH_Drawing_BrushSetAntiAlias(brush, true);
99 OH_Drawing_CanvasAttachBrush(bimap_canvas, brush);
100 OH_Drawing_CanvasTranslate(bimap_canvas, kImageSize / 2.0f, kImageSize / 2.0f); // 2.0f距离
101 for (int i = 0; i < kNumLines; ++i, angle += kAngleStep) {
102 float sin = sinf(angle);
103 float cos = cosf(angle);
104 OH_Drawing_CanvasDrawLine(bimap_canvas, cos * kInnerOffset, sin * kInnerOffset,
105 cos * kImageSize / 2, sin * kImageSize / 2); // 2 cout
106 }
107
108 OH_Drawing_CanvasDetachBrush(bimap_canvas);
109 OH_Drawing_ImageBuildFromBitmap(image, bitmap);
110 DrawImage(canvas, image, bitmap);
111
112 OH_Drawing_BitmapDestroy(bitmap);
113 OH_Drawing_ImageDestroy(image);
114 OH_Drawing_BrushDestroy(brush);
115 OH_Drawing_CanvasDestroy(bimap_canvas);
116 }
117